Socket
Socket
Sign inDemoInstall

@js-temporal/polyfill

Package Overview
Dependencies
2
Maintainers
3
Versions
9
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.4.2 to 0.4.3

index.d.cts

45

CHANGELOG.md

@@ -0,1 +1,33 @@

# 0.4.3
Bug fixes:
- Fix an off-by-one error when dates in the Hebrew calendar were created using
`monthCode`, the year was a leap year, and the month was after the leap
month ([f3d0ca9f])
- Fix addition of months and years for lunisolar calendars ([4f8b04c1])
- Fix the ISO8601 representation of years between 1 BCE and 999 BCE ([b251dc0e]).
- Fix a bug causing time to appear to go backwards for a small number of
milliseconds ([bb59ca97])
- Always validate ISO8601 time components as well as date components
([34662a05])
- Fix comparison of dates that might have a differing number of hours in their
respective days ([a4c60241])
- Include calendar reference information when `calendarName='always'` is passed
to various Temporal toString method's options bags ([54fcc4f3])
- Fix a nonconformant use of the `relativeTo` property bag ([9992f9b1])
- Fix ZonedDateTime.prototype.withPlainTime(null) to throw a TypeError, instead
of treating it as midnight ([ec2b0546])
- Fix parsing of some valid Instant strings when they would be out of range
before considering the UTC offset ([d9de9e74])
- Bail out early in non-ISO calendar implementations to avoid an infinte loop
when calculating the duration between two identical dates. ([6f3c42c9])
- Fix type resolution when using TypeScript Node16 and transpiling to CJS ([9bab0eb5], see
also the [relevant TypeScript issue](https://github.com/microsoft/TypeScript/issues/49160))
Non-breaking changes:
- Consistently call observable operations with undefined options arguments,
instead of empty objects ([297b8f38])
# 0.4.2

@@ -103,2 +135,15 @@

[f3d0ca9f]: https://github.com/js-temporal/temporal-polyfill/commit/f3d0ca9f2f32beb071a7d25c9732bd38784b3e6d
[4f8b04c1]: https://github.com/js-temporal/temporal-polyfill/commit/4f8b04c1caba0360a527cbe8c8d95e2a8642ab6e
[b251dc0e]: https://github.com/js-temporal/temporal-polyfill/commit/b251dc0ef48cd7b2edee2f6541ce0cfb6d019e08
[bb59ca97]: https://github.com/js-temporal/temporal-polyfill/commit/bb59ca970b1c0cb70bdafd2896814076c11edd07
[34662a05]: https://github.com/js-temporal/temporal-polyfill/commit/34662a05cfe50e17a02356cbc55ff0ca2365e888
[a4c60241]: https://github.com/js-temporal/temporal-polyfill/commit/a4c602410bb5b711683918cd414568e19c594499
[54fcc4f3]: https://github.com/js-temporal/temporal-polyfill/commit/54fcc4f34b6ce87d15d3df9359bb538766c562ef
[9992f9b1]: https://github.com/js-temporal/temporal-polyfill/commit/9992f9b1137ff52cc427bc0c96504dca387d267b
[ec2b0546]: https://github.com/js-temporal/temporal-polyfill/commit/ec2b0546dd68718c6645713512753570eccf0ba6
[d9de9e74]: https://github.com/js-temporal/temporal-polyfill/commit/d9de9e74d0cba630b3480b31964362f82c435992
[6f3c42c9]: https://github.com/js-temporal/temporal-polyfill/commit/6f3c42c90460fa0917e228b5724d7b462c052fd8
[9bab0eb5]: https://github.com/js-temporal/temporal-polyfill/commit/9bab0eb586a8db13081a51e81fd0f6f2518d041a
[297b8f38]: https://github.com/js-temporal/temporal-polyfill/commit/297b8f385e5a146ad9c97ce3a9865a654999a713
[304c86dd]: https://github.com/js-temporal/temporal-polyfill/commit/304c86dd61e7107095ed42149e85d919e3a6cac8

@@ -105,0 +150,0 @@ [b733c213]: https://github.com/js-temporal/temporal-polyfill/commit/b733c213cba462f79eb9ee3a084661ea5344d9ea

124

lib/duration.ts

@@ -47,19 +47,3 @@ import { DEBUG } from './debug';

const sign = ES.DurationSign(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds
);
for (const prop of [years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds]) {
if (!Number.isFinite(prop)) throw new RangeError('infinite values not allowed as duration fields');
const propSign = Math.sign(prop);
if (propSign !== 0 && propSign !== sign) throw new RangeError('mixed-sign values not allowed as duration fields');
}
ES.RejectDuration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);

@@ -161,14 +145,19 @@ CreateSlots(this);

if (!ES.IsTemporalDuration(this)) throw new TypeError('invalid receiver');
const props = ES.ToPartialRecord(durationLike, [
'days',
'hours',
'microseconds',
'milliseconds',
'minutes',
'months',
'nanoseconds',
'seconds',
'weeks',
'years'
]);
const props = ES.PrepareTemporalFields(
durationLike,
// NOTE: Field order here is important.
[
'days',
'hours',
'microseconds',
'milliseconds',
'minutes',
'months',
'nanoseconds',
'seconds',
'weeks',
'years'
],
'partial'
);
if (!props) {

@@ -210,63 +199,9 @@ throw new TypeError('invalid duration-like');

}
add(other: Params['add'][0], optionsParam: Params['add'][1] = undefined) {
add(other: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
if (!ES.IsTemporalDuration(this)) throw new TypeError('invalid receiver');
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.ToLimitedTemporalDuration(other);
const options = ES.GetOptionsObject(optionsParam);
const relativeTo = ES.ToRelativeTemporalObject(options);
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.AddDuration(
GetSlot(this, YEARS),
GetSlot(this, MONTHS),
GetSlot(this, WEEKS),
GetSlot(this, DAYS),
GetSlot(this, HOURS),
GetSlot(this, MINUTES),
GetSlot(this, SECONDS),
GetSlot(this, MILLISECONDS),
GetSlot(this, MICROSECONDS),
GetSlot(this, NANOSECONDS),
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
relativeTo
));
return new Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.AddDurationToOrSubtractDurationFromDuration('add', this, other, options);
}
subtract(other: Params['subtract'][0], optionsParam: Params['subtract'][1] = undefined) {
subtract(other: Params['subtract'][0], options: Params['subtract'][1] = undefined): Return['subtract'] {
if (!ES.IsTemporalDuration(this)) throw new TypeError('invalid receiver');
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.ToLimitedTemporalDuration(other);
const options = ES.GetOptionsObject(optionsParam);
const relativeTo = ES.ToRelativeTemporalObject(options);
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.AddDuration(
GetSlot(this, YEARS),
GetSlot(this, MONTHS),
GetSlot(this, WEEKS),
GetSlot(this, DAYS),
GetSlot(this, HOURS),
GetSlot(this, MINUTES),
GetSlot(this, SECONDS),
GetSlot(this, MILLISECONDS),
GetSlot(this, MICROSECONDS),
GetSlot(this, NANOSECONDS),
-years,
-months,
-weeks,
-days,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds,
relativeTo
));
return new Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.AddDurationToOrSubtractDurationFromDuration('subtract', this, other, options);
}

@@ -303,3 +238,3 @@ round(optionsParam: Params['round'][0]): Return['round'] {

: ES.GetOptionsObject(optionsParam);
let smallestUnit = ES.ToSmallestTemporalUnit(options, undefined);
let smallestUnit = ES.GetTemporalUnit(options, 'smallestUnit', 'datetime', undefined);
let smallestUnitPresent = true;

@@ -311,3 +246,3 @@ if (!smallestUnit) {

defaultLargestUnit = ES.LargerOfTwoTemporalUnits(defaultLargestUnit, smallestUnit);
let largestUnit = ES.ToLargestTemporalUnit(options, undefined);
let largestUnit = ES.GetTemporalUnit(options, 'largestUnit', 'datetime', undefined, ['auto']);
let largestUnitPresent = true;

@@ -322,3 +257,5 @@ if (!largestUnit) {

}
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
if (ES.LargerOfTwoTemporalUnits(largestUnit, smallestUnit) !== largestUnit) {
throw new RangeError(`largestUnit ${largestUnit} cannot be smaller than smallestUnit ${smallestUnit}`);
}
const roundingMode = ES.ToTemporalRoundingMode(options, 'halfExpand');

@@ -406,4 +343,3 @@ const roundingIncrement = ES.ToTemporalDateTimeRoundingIncrement(options, smallestUnit);

: ES.GetOptionsObject(optionsParam);
const unit = ES.ToTemporalDurationTotalUnit(options);
if (unit === undefined) throw new RangeError('unit option is required');
const unit = ES.GetTemporalUnit(options, 'unit', 'datetime', ES.REQUIRED);
const relativeTo = ES.ToRelativeTemporalObject(options);

@@ -520,4 +456,4 @@

let ns2 = GetSlot(two, NANOSECONDS);
const shift1 = ES.CalculateOffsetShift(relativeTo, y1, mon1, w1, d1, h1, min1, s1, ms1, µs1, ns1);
const shift2 = ES.CalculateOffsetShift(relativeTo, y2, mon2, w2, d2, h2, min2, s2, ms2, µs2, ns2);
const shift1 = ES.CalculateOffsetShift(relativeTo, y1, mon1, w1, d1);
const shift2 = ES.CalculateOffsetShift(relativeTo, y2, mon2, w2, d2);
if (y1 !== 0 || y2 !== 0 || mon1 !== 0 || mon2 !== 0 || w1 !== 0 || w2 !== 0) {

@@ -524,0 +460,0 @@ ({ days: d1 } = ES.UnbalanceDurationRelative(y1, mon1, w1, d1, 'day', relativeTo));

111

lib/instant.ts
import { DEBUG } from './debug';
import * as ES from './ecmascript';
import { GetIntrinsic, MakeIntrinsicClass } from './intrinsicclass';
import { MakeIntrinsicClass } from './intrinsicclass';
import { EPOCHNANOSECONDS, CreateSlots, GetSlot, SetSlot } from './slots';

@@ -12,12 +12,2 @@ import type { Temporal } from '..';

const DISALLOWED_UNITS = ['year', 'month', 'week', 'day'] as const;
const MAX_DIFFERENCE_INCREMENTS = {
hour: 24,
minute: 60,
second: 60,
millisecond: 1000,
microsecond: 1000,
nanosecond: 1000
};
export class Instant implements Temporal.Instant {

@@ -69,99 +59,15 @@ constructor(epochNanoseconds: bigint | JSBI) {

if (!ES.IsTemporalInstant(this)) throw new TypeError('invalid receiver');
const { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.ToLimitedTemporalDuration(
temporalDurationLike,
['years', 'months', 'weeks', 'days']
);
const ns = ES.AddInstant(
GetSlot(this, EPOCHNANOSECONDS),
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds
);
return new Instant(ns);
return ES.AddDurationToOrSubtractDurationFromInstant('add', this, temporalDurationLike);
}
subtract(temporalDurationLike: Params['subtract'][0]): Return['subtract'] {
if (!ES.IsTemporalInstant(this)) throw new TypeError('invalid receiver');
const { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.ToLimitedTemporalDuration(
temporalDurationLike,
['years', 'months', 'weeks', 'days']
);
const ns = ES.AddInstant(
GetSlot(this, EPOCHNANOSECONDS),
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds
);
return new Instant(ns);
return ES.AddDurationToOrSubtractDurationFromInstant('subtract', this, temporalDurationLike);
}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined) {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalInstant(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalInstant(otherParam);
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond', DISALLOWED_UNITS);
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('second', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, MAX_DIFFERENCE_INCREMENTS[smallestUnit], false);
const onens = GetSlot(this, EPOCHNANOSECONDS);
const twons = GetSlot(other, EPOCHNANOSECONDS);
let { seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceInstant(
onens,
twons,
roundingIncrement,
smallestUnit,
roundingMode
);
let hours, minutes;
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
0,
0,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(0, 0, 0, 0, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalInstant('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined) {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalInstant(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalInstant(otherParam);
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond', DISALLOWED_UNITS);
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('second', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, MAX_DIFFERENCE_INCREMENTS[smallestUnit], false);
const onens = GetSlot(other, EPOCHNANOSECONDS);
const twons = GetSlot(this, EPOCHNANOSECONDS);
let { seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceInstant(
onens,
twons,
roundingIncrement,
smallestUnit,
roundingMode
);
let hours, minutes;
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
0,
0,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(0, 0, 0, 0, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalInstant('since', this, other, options);
}

@@ -175,4 +81,3 @@ round(optionsParam: Params['round'][0]): Return['round'] {

: ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, undefined, DISALLOWED_UNITS);
if (smallestUnit === undefined) throw new RangeError('smallestUnit is required');
const smallestUnit = ES.GetTemporalUnit(options, 'smallestUnit', 'time', ES.REQUIRED);
const roundingMode = ES.ToTemporalRoundingMode(options, 'halfExpand');

@@ -179,0 +84,0 @@ const maximumIncrements = {

29

lib/internaltypes.d.ts

@@ -51,14 +51,21 @@ import type { Intl, Temporal } from '..';

export type AnyTemporalLikeType =
| Temporal.DurationLike
| Temporal.PlainDateLike
| Temporal.PlainDateTimeLike
| Temporal.PlainMonthDayLike
| Temporal.PlainTimeLike
| Temporal.PlainYearMonthLike
| Temporal.ZonedDateTimeLike;
// Used in AnyTemporalLikeType
// ts-prune-ignore-next
type AllTemporalLikeTypes = [
Temporal.DurationLike,
Temporal.PlainDateLike,
Temporal.PlainDateTimeLike,
Temporal.PlainMonthDayLike,
Temporal.PlainTimeLike,
Temporal.PlainYearMonthLike,
Temporal.ZonedDateTimeLike
];
export type AnyTemporalLikeType = AllTemporalLikeTypes[number];
// The properties below are all the names of Temporal properties that can be set with `with`.
// `timeZone` and `calendar` are not on the list because they have special methods to set them.
export type PrimitivePropertyNames =
// Used in PrimitiveFieldsOf
// ts-prune-ignore-next
type PrimitivePropertyNames =
| 'year'

@@ -88,2 +95,4 @@ | 'month'

export type PrimitiveFieldsOf<T extends AnyTemporalLikeType> = Pick<T, keyof T & PrimitivePropertyNames>;
export type UnitSmallerThanOrEqualTo<T extends Temporal.DateTimeUnit> = T extends 'year'

@@ -109,4 +118,2 @@ ? Temporal.DateTimeUnit

export type FieldRecord<B extends AnyTemporalLikeType> = readonly [keyof B, 0 | undefined] | readonly [keyof B];
// ts-prune complains about the type definitions below, even though they're used

@@ -113,0 +120,0 @@ // by exported types Not sure why and don't have time to investigate, so just

8

lib/intl.ts

@@ -175,3 +175,3 @@ import * as ES from './ecmascript';

const properties: Partial<typeof IntlDateTimeFormat.prototype> = {
const propertyDescriptors: Partial<Record<keyof Intl.DateTimeFormat, PropertyDescriptor>> = {
resolvedOptions: descriptor(resolvedOptions),

@@ -183,10 +183,10 @@ format: descriptor(format),

if ('formatToParts' in IntlDateTimeFormat.prototype) {
properties.formatToParts = descriptor(formatToParts);
propertyDescriptors.formatToParts = descriptor(formatToParts);
}
if ('formatRangeToParts' in IntlDateTimeFormat.prototype) {
properties.formatRangeToParts = descriptor(formatRangeToParts);
propertyDescriptors.formatRangeToParts = descriptor(formatRangeToParts);
}
DateTimeFormatImpl.prototype = Object.create(IntlDateTimeFormat.prototype, properties);
DateTimeFormatImpl.prototype = Object.create(IntlDateTimeFormat.prototype, propertyDescriptors);

@@ -193,0 +193,0 @@ // Ensure that the prototype isn't writeable.

108

lib/plaindate.ts
import * as ES from './ecmascript';
import { GetIntrinsic, MakeIntrinsicClass } from './intrinsicclass';
import { MakeIntrinsicClass } from './intrinsicclass';
import {

@@ -21,4 +21,2 @@ ISO_YEAR,

const DISALLOWED_UNITS = ['hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond'] as const;
export class PlainDate implements Temporal.PlainDate {

@@ -115,13 +113,13 @@ constructor(

const fieldNames = ES.CalendarFields(calendar, ['day', 'month', 'monthCode', 'year'] as const);
const props = ES.ToPartialRecord(temporalDateLike, fieldNames);
const props = ES.PrepareTemporalFields(temporalDateLike, fieldNames, 'partial');
if (!props) {
throw new TypeError('invalid date-like');
}
let fields = ES.ToTemporalDateFields(this, fieldNames);
let fields = ES.PrepareTemporalFields(this, fieldNames, []);
fields = ES.CalendarMergeFields(calendar, fields, props);
fields = ES.ToTemporalDateFields(fields, fieldNames);
fields = ES.PrepareTemporalFields(fields, fieldNames, []);
const options = ES.GetOptionsObject(optionsParam);
return ES.DateFromFields(calendar, fields, options);
return ES.CalendarDateFromFields(calendar, fields, options);
}

@@ -152,89 +150,9 @@ withCalendar(calendarParam: Params['withCalendar'][0]): Return['withCalendar'] {

}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined): Return['until'] {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalDate(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalDate(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'day', DISALLOWED_UNITS);
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('day', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, undefined, false);
const untilOptions = { ...options, largestUnit };
const result = ES.CalendarDateUntil(calendar, this, other, untilOptions);
if (smallestUnit === 'day' && roundingIncrement === 1) return result;
let { years, months, weeks, days } = result;
({ years, months, weeks, days } = ES.RoundDuration(
years,
months,
weeks,
days,
0,
0,
0,
0,
0,
0,
roundingIncrement,
smallestUnit,
roundingMode,
this
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(years, months, weeks, days, 0, 0, 0, 0, 0, 0);
return ES.DifferenceTemporalPlainDate('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined): Return['since'] {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalDate(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalDate(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'day', DISALLOWED_UNITS);
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('day', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, undefined, false);
const untilOptions = { ...options, largestUnit };
let { years, months, weeks, days } = ES.CalendarDateUntil(calendar, this, other, untilOptions);
const Duration = GetIntrinsic('%Temporal.Duration%');
if (smallestUnit === 'day' && roundingIncrement === 1) {
return new Duration(-years, -months, -weeks, -days, 0, 0, 0, 0, 0, 0);
}
({ years, months, weeks, days } = ES.RoundDuration(
years,
months,
weeks,
days,
0,
0,
0,
0,
0,
0,
roundingIncrement,
smallestUnit,
ES.NegateTemporalRoundingMode(roundingMode),
this
));
return new Duration(-years, -months, -weeks, -days, 0, 0, 0, 0, 0, 0);
return ES.DifferenceTemporalPlainDate('since', this, other, options);
}

@@ -363,4 +281,4 @@ equals(otherParam: Params['equals'][0]): Return['equals'] {

const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, fieldNames);
return ES.YearMonthFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarYearMonthFromFields(calendar, fields);
}

@@ -371,4 +289,4 @@ toPlainMonthDay(): Return['toPlainMonthDay'] {

const fieldNames = ES.CalendarFields(calendar, ['day', 'monthCode'] as const);
const fields = ES.ToTemporalMonthDayFields(this, fieldNames);
return ES.MonthDayFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarMonthDayFromFields(calendar, fields);
}

@@ -375,0 +293,0 @@ getISOFields(): Return['getISOFields'] {

264

lib/plaindatetime.ts
import * as ES from './ecmascript';
import { GetIntrinsic, MakeIntrinsicClass } from './intrinsicclass';
import { MakeIntrinsicClass } from './intrinsicclass';

@@ -173,9 +173,9 @@ import {

] as const);
const props = ES.ToPartialRecord(temporalDateTimeLike, fieldNames);
const props = ES.PrepareTemporalFields(temporalDateTimeLike, fieldNames, 'partial');
if (!props) {
throw new TypeError('invalid date-time-like');
}
let fields = ES.ToTemporalDateTimeFields(this, fieldNames);
let fields = ES.PrepareTemporalFields(this, fieldNames, []);
fields = ES.CalendarMergeFields(calendar, fields, props);
fields = ES.ToTemporalDateTimeFields(fields, fieldNames);
fields = ES.PrepareTemporalFields(fields, fieldNames, []);
const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } =

@@ -273,249 +273,20 @@ ES.InterpretTemporalDateTimeFields(calendar, fields, options);

}
add(temporalDurationLike: Params['add'][0], optionsParam: Params['add'][1] = undefined): Return['add'] {
add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
if (!ES.IsTemporalDateTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
const options = ES.GetOptionsObject(optionsParam);
const calendar = GetSlot(this, CALENDAR);
const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = ES.AddDateTime(
GetSlot(this, ISO_YEAR),
GetSlot(this, ISO_MONTH),
GetSlot(this, ISO_DAY),
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND),
calendar,
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
options
);
return ES.CreateTemporalDateTime(
year,
month,
day,
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
calendar
);
return ES.AddDurationToOrSubtractDurationFromPlainDateTime('add', this, temporalDurationLike, options);
}
subtract(
temporalDurationLike: Params['subtract'][0],
optionsParam: Params['subtract'][1] = undefined
options: Params['subtract'][1] = undefined
): Return['subtract'] {
if (!ES.IsTemporalDateTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
const options = ES.GetOptionsObject(optionsParam);
const calendar = GetSlot(this, CALENDAR);
const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = ES.AddDateTime(
GetSlot(this, ISO_YEAR),
GetSlot(this, ISO_MONTH),
GetSlot(this, ISO_DAY),
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND),
calendar,
-years,
-months,
-weeks,
-days,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds,
options
);
return ES.CreateTemporalDateTime(
year,
month,
day,
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
calendar
);
return ES.AddDurationToOrSubtractDurationFromPlainDateTime('subtract', this, temporalDurationLike, options);
}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined): Return['until'] {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalDateTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalDateTime(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond');
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('day', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', [], defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalDateTimeRoundingIncrement(options, smallestUnit);
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.DifferenceISODateTime(
GetSlot(this, ISO_YEAR),
GetSlot(this, ISO_MONTH),
GetSlot(this, ISO_DAY),
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND),
GetSlot(other, ISO_YEAR),
GetSlot(other, ISO_MONTH),
GetSlot(other, ISO_DAY),
GetSlot(other, ISO_HOUR),
GetSlot(other, ISO_MINUTE),
GetSlot(other, ISO_SECOND),
GetSlot(other, ISO_MILLISECOND),
GetSlot(other, ISO_MICROSECOND),
GetSlot(other, ISO_NANOSECOND),
calendar,
largestUnit,
options
);
const relativeTo = ES.TemporalDateTimeToDate(this);
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.RoundDuration(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode,
relativeTo
));
({ days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalPlainDateTime('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined): Return['since'] {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalDateTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalDateTime(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond');
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('day', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', [], defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalDateTimeRoundingIncrement(options, smallestUnit);
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.DifferenceISODateTime(
GetSlot(this, ISO_YEAR),
GetSlot(this, ISO_MONTH),
GetSlot(this, ISO_DAY),
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND),
GetSlot(other, ISO_YEAR),
GetSlot(other, ISO_MONTH),
GetSlot(other, ISO_DAY),
GetSlot(other, ISO_HOUR),
GetSlot(other, ISO_MINUTE),
GetSlot(other, ISO_SECOND),
GetSlot(other, ISO_MILLISECOND),
GetSlot(other, ISO_MICROSECOND),
GetSlot(other, ISO_NANOSECOND),
calendar,
largestUnit,
options
);
const relativeTo = ES.TemporalDateTimeToDate(this);
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.RoundDuration(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
ES.NegateTemporalRoundingMode(roundingMode),
relativeTo
));
({ days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(
-years,
-months,
-weeks,
-days,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds
);
return ES.DifferenceTemporalPlainDateTime('since', this, other, options);
}

@@ -529,4 +300,3 @@ round(optionsParam: Params['round'][0]): Return['round'] {

: ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, undefined, ['year', 'month', 'week']);
if (smallestUnit === undefined) throw new RangeError('smallestUnit is required');
const smallestUnit = ES.GetTemporalUnit(options, 'smallestUnit', 'time', ES.REQUIRED, ['day']);
const roundingMode = ES.ToTemporalRoundingMode(options, 'halfExpand');

@@ -643,4 +413,4 @@ const maximumIncrements = {

const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, fieldNames);
return ES.YearMonthFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarYearMonthFromFields(calendar, fields);
}

@@ -651,4 +421,4 @@ toPlainMonthDay(): Return['toPlainMonthDay'] {

const fieldNames = ES.CalendarFields(calendar, ['day', 'monthCode'] as const);
const fields = ES.ToTemporalMonthDayFields(this, fieldNames);
return ES.MonthDayFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarMonthDayFromFields(calendar, fields);
}

@@ -655,0 +425,0 @@ toPlainTime(): Return['toPlainTime'] {

34

lib/plainmonthday.ts

@@ -6,3 +6,3 @@ import * as ES from './ecmascript';

import { DateTimeFormat } from './intl';
import type { FieldRecord, PlainMonthDayParams as Params, PlainMonthDayReturn as Return } from './internaltypes';
import type { PlainMonthDayParams as Params, PlainMonthDayReturn as Return } from './internaltypes';

@@ -56,12 +56,12 @@ const ObjectCreate = Object.create;

const fieldNames = ES.CalendarFields(calendar, ['day', 'month', 'monthCode', 'year'] as const);
const props = ES.ToPartialRecord(temporalMonthDayLike, fieldNames);
const props = ES.PrepareTemporalFields(temporalMonthDayLike, fieldNames, 'partial');
if (!props) {
throw new TypeError('invalid month-day-like');
}
let fields = ES.ToTemporalMonthDayFields(this, fieldNames);
let fields = ES.PrepareTemporalFields(this, fieldNames, []);
fields = ES.CalendarMergeFields(calendar, fields, props);
fields = ES.ToTemporalMonthDayFields(fields, fieldNames);
fields = ES.PrepareTemporalFields(fields, fieldNames, []);
const options = ES.GetOptionsObject(optionsParam);
return ES.MonthDayFromFields(calendar, fields, options);
return ES.CalendarMonthDayFromFields(calendar, fields, options);
}

@@ -104,26 +104,14 @@ equals(otherParam: Params['equals'][0]): Return['equals'] {

const receiverFieldNames = ES.CalendarFields(calendar, ['day', 'monthCode'] as const);
const fields = ES.ToTemporalMonthDayFields(this, receiverFieldNames);
const fields = ES.PrepareTemporalFields(this, receiverFieldNames, []);
const inputFieldNames = ES.CalendarFields(calendar, ['year']);
const inputEntries: FieldRecord<Temporal.PlainMonthDayLike>[] = [['year', undefined]];
// Add extra fields from the calendar at the end
inputFieldNames.forEach((fieldName) => {
if (!inputEntries.some(([name]) => name === fieldName)) {
inputEntries.push([fieldName, undefined] as typeof inputEntries[number]); // Make TS ignore extra fields
}
});
const inputFields = ES.PrepareTemporalFields(item, inputEntries);
const inputFieldNames = ES.CalendarFields(calendar, ['year'] as const);
const inputFields = ES.PrepareTemporalFields(item, inputFieldNames, []);
let mergedFields = ES.CalendarMergeFields(calendar, fields, inputFields);
// TODO: Use MergeLists abstract operation.
const mergedFieldNames = [...new Set([...receiverFieldNames, ...inputFieldNames])];
const mergedEntries: FieldRecord<Temporal.PlainMonthDayLike>[] = [];
mergedFieldNames.forEach((fieldName) => {
if (!mergedEntries.some(([name]) => name === fieldName)) {
mergedEntries.push([fieldName, undefined] as typeof mergedEntries[number]);
}
});
mergedFields = ES.PrepareTemporalFields(mergedFields, mergedEntries);
mergedFields = ES.PrepareTemporalFields(mergedFields, mergedFieldNames, []);
const options = ObjectCreate(null);
options.overflow = 'reject';
return ES.DateFromFields(calendar, mergedFields, options);
return ES.CalendarDateFromFields(calendar, mergedFields, options);
}

@@ -130,0 +118,0 @@ getISOFields(): Return['getISOFields'] {

209

lib/plaintime.ts

@@ -27,12 +27,2 @@ import { DEBUG } from './debug';

const DISALLOWED_UNITS = ['year', 'month', 'week', 'day'] as const;
const MAX_INCREMENTS = {
hour: 24,
minute: 60,
second: 60,
millisecond: 1000,
microsecond: 1000,
nanosecond: 1000
};
type TemporalTimeToStringOptions = {

@@ -150,18 +140,8 @@ unit: ReturnType<typeof ES.ToSecondsStringPrecision>['unit'];

const partialTime = ES.ToTemporalTimeRecord(temporalTimeLike, 'partial');
const options = ES.GetOptionsObject(optionsParam);
const overflow = ES.ToTemporalOverflow(options);
const props = ES.ToPartialRecord(temporalTimeLike, [
'hour',
'microsecond',
'millisecond',
'minute',
'nanosecond',
'second'
]);
if (!props) {
throw new TypeError('invalid time-like');
}
const fields = ES.ToTemporalTimeRecord(this);
let { hour, minute, second, millisecond, microsecond, nanosecond } = ObjectAssign(fields, props);
let { hour, minute, second, millisecond, microsecond, nanosecond } = ObjectAssign(fields, partialTime);
({ hour, minute, second, millisecond, microsecond, nanosecond } = ES.RegulateTime(

@@ -180,177 +160,15 @@ hour,

if (!ES.IsTemporalTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
let hour = GetSlot(this, ISO_HOUR);
let minute = GetSlot(this, ISO_MINUTE);
let second = GetSlot(this, ISO_SECOND);
let millisecond = GetSlot(this, ISO_MILLISECOND);
let microsecond = GetSlot(this, ISO_MICROSECOND);
let nanosecond = GetSlot(this, ISO_NANOSECOND);
({ hour, minute, second, millisecond, microsecond, nanosecond } = ES.AddTime(
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds
));
({ hour, minute, second, millisecond, microsecond, nanosecond } = ES.RegulateTime(
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
'reject'
));
return new PlainTime(hour, minute, second, millisecond, microsecond, nanosecond);
return ES.AddDurationToOrSubtractDurationFromPlainTime('add', this, temporalDurationLike);
}
subtract(temporalDurationLike: Params['subtract'][0]): Return['subtract'] {
if (!ES.IsTemporalTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
let hour = GetSlot(this, ISO_HOUR);
let minute = GetSlot(this, ISO_MINUTE);
let second = GetSlot(this, ISO_SECOND);
let millisecond = GetSlot(this, ISO_MILLISECOND);
let microsecond = GetSlot(this, ISO_MICROSECOND);
let nanosecond = GetSlot(this, ISO_NANOSECOND);
({ hour, minute, second, millisecond, microsecond, nanosecond } = ES.AddTime(
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds
));
({ hour, minute, second, millisecond, microsecond, nanosecond } = ES.RegulateTime(
hour,
minute,
second,
millisecond,
microsecond,
nanosecond,
'reject'
));
return new PlainTime(hour, minute, second, millisecond, microsecond, nanosecond);
return ES.AddDurationToOrSubtractDurationFromPlainTime('subtract', this, temporalDurationLike);
}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined): Return['until'] {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalTime(otherParam);
const options = ES.GetOptionsObject(optionsParam);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, 'hour');
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond', DISALLOWED_UNITS);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, MAX_INCREMENTS[smallestUnit], false);
let { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceTime(
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND),
GetSlot(other, ISO_HOUR),
GetSlot(other, ISO_MINUTE),
GetSlot(other, ISO_SECOND),
GetSlot(other, ISO_MILLISECOND),
GetSlot(other, ISO_MICROSECOND),
GetSlot(other, ISO_NANOSECOND)
);
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.RoundDuration(
0,
0,
0,
0,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode
));
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(0, 0, 0, 0, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalPlainTime('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined): Return['since'] {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalTime(otherParam);
const options = ES.GetOptionsObject(optionsParam);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, 'hour');
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond', DISALLOWED_UNITS);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, MAX_INCREMENTS[smallestUnit], false);
let { hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceTime(
GetSlot(other, ISO_HOUR),
GetSlot(other, ISO_MINUTE),
GetSlot(other, ISO_SECOND),
GetSlot(other, ISO_MILLISECOND),
GetSlot(other, ISO_MICROSECOND),
GetSlot(other, ISO_NANOSECOND),
GetSlot(this, ISO_HOUR),
GetSlot(this, ISO_MINUTE),
GetSlot(this, ISO_SECOND),
GetSlot(this, ISO_MILLISECOND),
GetSlot(this, ISO_MICROSECOND),
GetSlot(this, ISO_NANOSECOND)
);
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.RoundDuration(
0,
0,
0,
0,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds,
roundingIncrement,
smallestUnit,
ES.NegateTemporalRoundingMode(roundingMode)
));
hours = -hours;
minutes = -minutes;
seconds = -seconds;
milliseconds = -milliseconds;
microseconds = -microseconds;
nanoseconds = -nanoseconds;
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(0, 0, 0, 0, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalPlainTime('since', this, other, options);
}

@@ -364,5 +182,12 @@ round(optionsParam: Params['round'][0]): Return['round'] {

: ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, undefined, DISALLOWED_UNITS);
if (smallestUnit === undefined) throw new RangeError('smallestUnit is required');
const smallestUnit = ES.GetTemporalUnit(options, 'smallestUnit', 'time', ES.REQUIRED);
const roundingMode = ES.ToTemporalRoundingMode(options, 'halfExpand');
const MAX_INCREMENTS = {
hour: 24,
minute: 60,
second: 60,
millisecond: 1000,
microsecond: 1000,
nanosecond: 1000
};
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, MAX_INCREMENTS[smallestUnit], false);

@@ -369,0 +194,0 @@

202

lib/plainyearmonth.ts
import * as ES from './ecmascript';
import { GetIntrinsic, MakeIntrinsicClass } from './intrinsicclass';
import { MakeIntrinsicClass } from './intrinsicclass';
import { ISO_YEAR, ISO_MONTH, ISO_DAY, CALENDAR, GetSlot } from './slots';
import type { Temporal } from '..';
import { DateTimeFormat } from './intl';
import type { FieldRecord, PlainYearMonthParams as Params, PlainYearMonthReturn as Return } from './internaltypes';
import type { PlainYearMonthParams as Params, PlainYearMonthReturn as Return } from './internaltypes';
const ObjectCreate = Object.create;
const DISALLOWED_UNITS = [
'week',
'day',
'hour',
'minute',
'second',
'millisecond',
'microsecond',
'nanosecond'
] as const;
export class PlainYearMonth implements Temporal.PlainYearMonth {

@@ -92,168 +81,32 @@ constructor(

const fieldNames = ES.CalendarFields(calendar, ['month', 'monthCode', 'year'] as const);
const props = ES.ToPartialRecord(temporalYearMonthLike, fieldNames);
const props = ES.PrepareTemporalFields(temporalYearMonthLike, fieldNames, 'partial');
if (!props) {
throw new TypeError('invalid year-month-like');
}
let fields = ES.ToTemporalYearMonthFields(this, fieldNames);
let fields = ES.PrepareTemporalFields(this, fieldNames, []);
fields = ES.CalendarMergeFields(calendar, fields, props);
fields = ES.ToTemporalYearMonthFields(fields, fieldNames);
fields = ES.PrepareTemporalFields(fields, fieldNames, []);
const options = ES.GetOptionsObject(optionsParam);
return ES.YearMonthFromFields(calendar, fields, options);
return ES.CalendarYearMonthFromFields(calendar, fields, options);
}
add(temporalDurationLike: Params['add'][0], optionsParam: Params['add'][1] = undefined): Return['add'] {
add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
if (!ES.IsTemporalYearMonth(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
({ days } = ES.BalanceDuration(days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, 'day'));
const options = ES.GetOptionsObject(optionsParam);
const calendar = GetSlot(this, CALENDAR);
const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, fieldNames);
const sign = ES.DurationSign(years, months, weeks, days, 0, 0, 0, 0, 0, 0);
const day = sign < 0 ? ES.ToPositiveInteger(ES.CalendarDaysInMonth(calendar, this)) : 1;
const startDate = ES.DateFromFields(calendar, { ...fields, day });
const optionsCopy = { ...options };
const addedDate = ES.CalendarDateAdd(calendar, startDate, { ...duration, days }, options);
const addedDateFields = ES.ToTemporalYearMonthFields(addedDate, fieldNames);
return ES.YearMonthFromFields(calendar, addedDateFields, optionsCopy);
return ES.AddDurationToOrSubtractDurationFromPlainYearMonth('add', this, temporalDurationLike, options);
}
subtract(
temporalDurationLike: Params['subtract'][0],
optionsParam: Params['subtract'][1] = undefined
options: Params['subtract'][1] = undefined
): Return['subtract'] {
if (!ES.IsTemporalYearMonth(this)) throw new TypeError('invalid receiver');
let duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
duration = {
years: -duration.years,
months: -duration.months,
weeks: -duration.weeks,
days: -duration.days,
hours: -duration.hours,
minutes: -duration.minutes,
seconds: -duration.seconds,
milliseconds: -duration.milliseconds,
microseconds: -duration.microseconds,
nanoseconds: -duration.nanoseconds
};
let { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
({ days } = ES.BalanceDuration(days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, 'day'));
const options = ES.GetOptionsObject(optionsParam);
const calendar = GetSlot(this, CALENDAR);
const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, fieldNames);
const sign = ES.DurationSign(years, months, weeks, days, 0, 0, 0, 0, 0, 0);
const day = sign < 0 ? ES.ToPositiveInteger(ES.CalendarDaysInMonth(calendar, this)) : 1;
const startDate = ES.DateFromFields(calendar, { ...fields, day });
const optionsCopy = { ...options };
const addedDate = ES.CalendarDateAdd(calendar, startDate, { ...duration, days }, options);
const addedDateFields = ES.ToTemporalYearMonthFields(addedDate, fieldNames);
return ES.YearMonthFromFields(calendar, addedDateFields, optionsCopy);
return ES.AddDurationToOrSubtractDurationFromPlainYearMonth('subtract', this, temporalDurationLike, options);
}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined): Return['until'] {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalYearMonth(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalYearMonth(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarID = ES.ToString(calendar);
const otherCalendarID = ES.ToString(otherCalendar);
if (calendarID !== otherCalendarID) {
throw new RangeError(
`cannot compute difference between months of ${calendarID} and ${otherCalendarID} calendars`
);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'month', DISALLOWED_UNITS);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, 'year');
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, undefined, false);
const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const otherFields = ES.ToTemporalYearMonthFields(other, fieldNames);
const thisFields = ES.ToTemporalYearMonthFields(this, fieldNames);
const otherDate = ES.DateFromFields(calendar, { ...otherFields, day: 1 });
const thisDate = ES.DateFromFields(calendar, { ...thisFields, day: 1 });
const untilOptions = { ...options, largestUnit };
const result = ES.CalendarDateUntil(calendar, thisDate, otherDate, untilOptions);
if (smallestUnit === 'month' && roundingIncrement === 1) return result;
let { years, months } = result;
({ years, months } = ES.RoundDuration(
years,
months,
0,
0,
0,
0,
0,
0,
0,
0,
roundingIncrement,
smallestUnit,
roundingMode,
thisDate
));
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(years, months, 0, 0, 0, 0, 0, 0, 0, 0);
return ES.DifferenceTemporalPlainYearMonth('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined): Return['since'] {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalYearMonth(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalYearMonth(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarID = ES.ToString(calendar);
const otherCalendarID = ES.ToString(otherCalendar);
if (calendarID !== otherCalendarID) {
throw new RangeError(
`cannot compute difference between months of ${calendarID} and ${otherCalendarID} calendars`
);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'month', DISALLOWED_UNITS);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', DISALLOWED_UNITS, 'year');
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalRoundingIncrement(options, undefined, false);
const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const otherFields = ES.ToTemporalYearMonthFields(other, fieldNames);
const thisFields = ES.ToTemporalYearMonthFields(this, fieldNames);
const otherDate = ES.DateFromFields(calendar, { ...otherFields, day: 1 });
const thisDate = ES.DateFromFields(calendar, { ...thisFields, day: 1 });
const untilOptions = { ...options, largestUnit };
let { years, months } = ES.CalendarDateUntil(calendar, thisDate, otherDate, untilOptions);
const Duration = GetIntrinsic('%Temporal.Duration%');
if (smallestUnit === 'month' && roundingIncrement === 1) {
return new Duration(-years, -months, 0, 0, 0, 0, 0, 0, 0, 0);
}
({ years, months } = ES.RoundDuration(
years,
months,
0,
0,
0,
0,
0,
0,
0,
0,
roundingIncrement,
smallestUnit,
ES.NegateTemporalRoundingMode(roundingMode),
thisDate
));
return new Duration(-years, -months, 0, 0, 0, 0, 0, 0, 0, 0);
return ES.DifferenceTemporalPlainYearMonth('since', this, other, options);
}

@@ -296,29 +149,14 @@ equals(otherParam: Params['equals'][0]): Return['equals'] {

const receiverFieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, receiverFieldNames);
const fields = ES.PrepareTemporalFields(this, receiverFieldNames, []);
const inputFieldNames = ES.CalendarFields(calendar, ['day']);
const inputEntries: FieldRecord<Temporal.PlainYearMonthLike & { day?: number }>[] = [['day']];
// Add extra fields from the calendar at the end
inputFieldNames.forEach((fieldName) => {
if (!inputEntries.some(([name]) => name === fieldName)) {
(inputEntries as unknown as Array<typeof inputEntries[number]>).push([
fieldName,
undefined
] as unknown as typeof inputEntries[number]); // Make TS ignore extra fields
}
});
const inputFields = ES.PrepareTemporalFields(item, inputEntries);
const inputFieldNames = ES.CalendarFields(calendar, ['day'] as const);
const inputFields = ES.PrepareTemporalFields(item, inputFieldNames, []);
let mergedFields = ES.CalendarMergeFields(calendar, fields, inputFields);
// TODO: Use MergeLists abstract operation.
const mergedFieldNames = [...new Set([...receiverFieldNames, ...inputFieldNames])];
const mergedEntries: FieldRecord<Temporal.PlainMonthDayLike>[] = [];
mergedFieldNames.forEach((fieldName) => {
if (!mergedEntries.some(([name]) => name === fieldName)) {
mergedEntries.push([fieldName, undefined] as typeof mergedEntries[number]);
}
});
mergedFields = ES.PrepareTemporalFields(mergedFields, mergedEntries);
mergedFields = ES.PrepareTemporalFields(mergedFields, mergedFieldNames, []);
const options = ObjectCreate(null);
options.overflow = 'reject';
return ES.DateFromFields(calendar, mergedFields, options);
return ES.CalendarDateFromFields(calendar, mergedFields, options);
}

@@ -325,0 +163,0 @@ getISOFields(): Return['getISOFields'] {

301

lib/zoneddatetime.ts

@@ -26,4 +26,2 @@ import * as ES from './ecmascript';

const ArrayPrototypePush = Array.prototype.push;
export class ZonedDateTime implements Temporal.ZonedDateTime {

@@ -185,2 +183,3 @@ constructor(

// TODO: Reorder according to spec.
const options = ES.GetOptionsObject(optionsParam);

@@ -204,32 +203,9 @@ const disambiguation = ES.ToTemporalDisambiguation(options);

] as const);
ArrayPrototypePush.call(fieldNames, 'offset');
const props = ES.ToPartialRecord(temporalZonedDateTimeLike, fieldNames);
if (!props) {
throw new TypeError('invalid zoned-date-time-like');
}
// Unlike ToTemporalZonedDateTimeFields, the offset property will be required.
const entries: ([keyof Temporal.ZonedDateTimeLike, 0 | undefined] | ['timeZone'] | ['offset'])[] = [
['day', undefined],
['hour', 0],
['microsecond', 0],
['millisecond', 0],
['minute', 0],
['month', undefined],
['monthCode', undefined],
['nanosecond', 0],
['second', 0],
['year', undefined],
['offset'],
['timeZone']
];
// Add extra fields from the calendar at the end
fieldNames.forEach((fieldName) => {
if (!entries.some(([name]) => name === fieldName)) {
entries.push([fieldName, undefined]);
}
});
let fields = ES.PrepareTemporalFields(this, entries);
const fieldsWithOffset = ES.ArrayPush(fieldNames, 'offset');
const props = ES.PrepareTemporalFields(temporalZonedDateTimeLike, fieldsWithOffset, 'partial');
const fieldsWithTimeZoneAndOffset = ES.ArrayPush(fieldsWithOffset, 'timeZone');
let fields = ES.PrepareTemporalFields(this, fieldsWithTimeZoneAndOffset, ['timeZone', 'offset']);
fields = ES.CalendarMergeFields(calendar, fields, props);
fields = ES.PrepareTemporalFields(fields, entries);
const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } =
fields = ES.PrepareTemporalFields(fields, fieldsWithTimeZoneAndOffset, ['timeZone', 'offset']);
let { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } =
ES.InterpretTemporalDateTimeFields(calendar, fields, options);

@@ -296,3 +272,3 @@ const offsetNs = ES.ParseTimeZoneOffsetString(fields.offset);

const PlainTime = GetIntrinsic('%Temporal.PlainTime%');
const temporalTime = temporalTimeParam == undefined ? new PlainTime() : ES.ToTemporalTime(temporalTimeParam);
const temporalTime = temporalTimeParam === undefined ? new PlainTime() : ES.ToTemporalTime(temporalTimeParam);

@@ -338,254 +314,20 @@ const thisDt = dateTime(this);

}
add(temporalDurationLike: Params['add'][0], optionsParam: Params['add'][1] = undefined): Return['add'] {
add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
if (!ES.IsTemporalZonedDateTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
const options = ES.GetOptionsObject(optionsParam);
const timeZone = GetSlot(this, TIME_ZONE);
const calendar = GetSlot(this, CALENDAR);
const epochNanoseconds = ES.AddZonedDateTime(
GetSlot(this, INSTANT),
timeZone,
calendar,
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
options
);
return ES.CreateTemporalZonedDateTime(epochNanoseconds, timeZone, calendar);
return ES.AddDurationToOrSubtractDurationFromZonedDateTime('add', this, temporalDurationLike, options);
}
subtract(
temporalDurationLike: Params['subtract'][0],
optionsParam: Params['subtract'][1] = undefined
options: Params['subtract'][1] = undefined
): Return['subtract'] {
if (!ES.IsTemporalZonedDateTime(this)) throw new TypeError('invalid receiver');
const duration = ES.ToLimitedTemporalDuration(temporalDurationLike);
const { years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = duration;
const options = ES.GetOptionsObject(optionsParam);
const timeZone = GetSlot(this, TIME_ZONE);
const calendar = GetSlot(this, CALENDAR);
const epochNanoseconds = ES.AddZonedDateTime(
GetSlot(this, INSTANT),
timeZone,
calendar,
-years,
-months,
-weeks,
-days,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds,
options
);
return ES.CreateTemporalZonedDateTime(epochNanoseconds, timeZone, calendar);
return ES.AddDurationToOrSubtractDurationFromZonedDateTime('subtract', this, temporalDurationLike, options);
}
until(otherParam: Params['until'][0], optionsParam: Params['until'][1] = undefined) {
until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
if (!ES.IsTemporalZonedDateTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalZonedDateTime(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond');
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('hour', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', [], defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
const roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
const roundingIncrement = ES.ToTemporalDateTimeRoundingIncrement(options, smallestUnit);
const ns1 = GetSlot(this, EPOCHNANOSECONDS);
const ns2 = GetSlot(other, EPOCHNANOSECONDS);
let years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds;
if (largestUnit !== 'year' && largestUnit !== 'month' && largestUnit !== 'week' && largestUnit !== 'day') {
// The user is only asking for a time difference, so return difference of instants.
years = 0;
months = 0;
weeks = 0;
days = 0;
({ seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceInstant(
ns1,
ns2,
roundingIncrement,
smallestUnit as Temporal.TimeUnit,
roundingMode
));
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
0,
0,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
} else {
const timeZone = GetSlot(this, TIME_ZONE);
if (!ES.TimeZoneEquals(timeZone, GetSlot(other, TIME_ZONE))) {
throw new RangeError(
"When calculating difference between time zones, largestUnit must be 'hours' " +
'or smaller because day lengths can vary between time zones due to DST or time zone offset changes.'
);
}
const untilOptions = { ...options, largestUnit };
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.DifferenceZonedDateTime(ns1, ns2, timeZone, calendar, largestUnit, untilOptions));
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.RoundDuration(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode,
this
));
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.AdjustRoundedDurationDays(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode,
this
));
}
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
return ES.DifferenceTemporalZonedDateTime('until', this, other, options);
}
since(otherParam: Params['since'][0], optionsParam: Params['since'][1] = undefined) {
since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
if (!ES.IsTemporalZonedDateTime(this)) throw new TypeError('invalid receiver');
const other = ES.ToTemporalZonedDateTime(otherParam);
const calendar = GetSlot(this, CALENDAR);
const otherCalendar = GetSlot(other, CALENDAR);
const calendarId = ES.ToString(calendar);
const otherCalendarId = ES.ToString(otherCalendar);
if (calendarId !== otherCalendarId) {
throw new RangeError(`cannot compute difference between dates of ${calendarId} and ${otherCalendarId} calendars`);
}
const options = ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, 'nanosecond');
const defaultLargestUnit = ES.LargerOfTwoTemporalUnits('hour', smallestUnit);
const largestUnit = ES.ToLargestTemporalUnit(options, 'auto', [], defaultLargestUnit);
ES.ValidateTemporalUnitRange(largestUnit, smallestUnit);
let roundingMode = ES.ToTemporalRoundingMode(options, 'trunc');
roundingMode = ES.NegateTemporalRoundingMode(roundingMode);
const roundingIncrement = ES.ToTemporalDateTimeRoundingIncrement(options, smallestUnit);
const ns1 = GetSlot(this, EPOCHNANOSECONDS);
const ns2 = GetSlot(other, EPOCHNANOSECONDS);
let years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds;
if (largestUnit !== 'year' && largestUnit !== 'month' && largestUnit !== 'week' && largestUnit !== 'day') {
// The user is only asking for a time difference, so return difference of instants.
years = 0;
months = 0;
weeks = 0;
days = 0;
({ seconds, milliseconds, microseconds, nanoseconds } = ES.DifferenceInstant(
ns1,
ns2,
roundingIncrement,
smallestUnit as Temporal.TimeUnit,
roundingMode
));
({ hours, minutes, seconds, milliseconds, microseconds, nanoseconds } = ES.BalanceDuration(
0,
0,
0,
seconds,
milliseconds,
microseconds,
nanoseconds,
largestUnit
));
} else {
const timeZone = GetSlot(this, TIME_ZONE);
if (!ES.TimeZoneEquals(timeZone, GetSlot(other, TIME_ZONE))) {
throw new RangeError(
"When calculating difference between time zones, largestUnit must be 'hours' " +
'or smaller because day lengths can vary between time zones due to DST or time zone offset changes.'
);
}
const untilOptions = { ...options, largestUnit };
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.DifferenceZonedDateTime(ns1, ns2, timeZone, calendar, largestUnit, untilOptions));
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.RoundDuration(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode,
this
));
({ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds } =
ES.AdjustRoundedDurationDays(
years,
months,
weeks,
days,
hours,
minutes,
seconds,
milliseconds,
microseconds,
nanoseconds,
roundingIncrement,
smallestUnit,
roundingMode,
this
));
}
const Duration = GetIntrinsic('%Temporal.Duration%');
return new Duration(
-years,
-months,
-weeks,
-days,
-hours,
-minutes,
-seconds,
-milliseconds,
-microseconds,
-nanoseconds
);
return ES.DifferenceTemporalZonedDateTime('since', this, other, options);
}

@@ -599,4 +341,3 @@ round(optionsParam: Params['round'][0]): Return['round'] {

: ES.GetOptionsObject(optionsParam);
const smallestUnit = ES.ToSmallestTemporalUnit(options, undefined, ['year', 'month', 'week']);
if (smallestUnit === undefined) throw new RangeError('smallestUnit is required');
const smallestUnit = ES.GetTemporalUnit(options, 'smallestUnit', 'time', ES.REQUIRED, ['day']);
const roundingMode = ES.ToTemporalRoundingMode(options, 'halfExpand');

@@ -759,4 +500,4 @@ const maximumIncrements = {

const fieldNames = ES.CalendarFields(calendar, ['monthCode', 'year'] as const);
const fields = ES.ToTemporalYearMonthFields(this, fieldNames);
return ES.YearMonthFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarYearMonthFromFields(calendar, fields);
}

@@ -767,4 +508,4 @@ toPlainMonthDay(): Return['toPlainMonthDay'] {

const fieldNames = ES.CalendarFields(calendar, ['day', 'monthCode'] as const);
const fields = ES.ToTemporalMonthDayFields(this, fieldNames);
return ES.MonthDayFromFields(calendar, fields);
const fields = ES.PrepareTemporalFields(this, fieldNames, []);
return ES.CalendarMonthDayFromFields(calendar, fields);
}

@@ -771,0 +512,0 @@ getISOFields(): Return['getISOFields'] {

12

package.json
{
"name": "@js-temporal/polyfill",
"version": "0.4.2",
"version": "0.4.3",
"description": "Polyfill for Tc39 Stage 3 proposal Temporal (https://github.com/tc39/proposal-temporal)",

@@ -16,2 +16,6 @@ "type": "module",

},
"require": {
"types": "./index.d.cts",
"default": "./dist/index.cjs"
},
"default": "./dist/index.cjs"

@@ -24,7 +28,8 @@ },

"scripts": {
"test": "tsc && node --no-warnings --experimental-modules --experimental-specifier-resolution=node --icu-data-dir node_modules/full-icu --loader ./test/resolve.source.mjs ./test/all.mjs",
"test": "npm run build && node --no-warnings --experimental-modules --experimental-specifier-resolution=node --icu-data-dir node_modules/full-icu --loader ./test/resolve.source.mjs ./test/all.mjs",
"test262": "TEST262=1 npm run build && ./test/test262.sh",
"testValidStrings": "npm run build && node --experimental-modules --experimental-specifier-resolution=node --no-warnings --icu-data-dir ./node_modules/full-icu/ --loader ./test/resolve.source.mjs test/validStrings.mjs",
"build": "rm -rf dist/* tsc-out/* && tsc && rollup -c rollup.config.js",
"prepare": "npm run build",
"prepublishOnly": "npm run build",
"prepublishOnly": "node copy-types.mjs && npm run build",
"update": "npx npm-check-updates -u -x @pipobscure/demitasse && npm install",

@@ -73,2 +78,3 @@ "playground": "TEMPORAL_PLAYGROUND=1 npm run build && node --experimental-modules --no-warnings --icu-data-dir node_modules/full-icu -r ./dist/playground.cjs",

"index.d.ts",
"index.d.cts",
"dist",

@@ -75,0 +81,0 @@ "lib",

2

README.md

@@ -77,2 +77,4 @@ # Temporal Polyfill

This polyfill uses [JSBI](https://github.com/GoogleChromeLabs/jsbi) to enable backwards-compatibility for environments that don't support native bigints. If your project only ever runs in environments that do support native bigints (see [caniuse data](https://caniuse.com/bigint)), we highly recommend configuring the [JSBI Babel plugin](https://github.com/GoogleChromeLabs/babel-plugin-transform-jsbi-to-bigint) that translates JSBI calls to their native bigint equivalent, improving code-size and performance. We are exploring ways to provide separate builds for these use-cases in [#155](https://github.com/js-temporal/temporal-polyfill/issues/155).
## Contributing / Help Wanted

@@ -79,0 +81,0 @@ 

dist/index.cjs

Sorry, the diff of this file is not supported yet

dist/index.cjs.map

Sorry, the diff of this file is not supported yet

dist/index.esm.js

Sorry, the diff of this file is too big to display

dist/index.esm.js.map

Sorry, the diff of this file is not supported yet

dist/index.umd.js

Sorry, the diff of this file is too big to display

dist/index.umd.js.map

Sorry, the diff of this file is not supported yet

lib/calendar.ts

Sorry, the diff of this file is too big to display

lib/ecmascript.ts

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc