[DRAFT] [JSC] Implement Temporal.ZonedDateTime (offset time zones only)

JSTests/stress/temporal-duration.js

@@ -116,6 +116,7 @@ shouldBe(Temporal.Duration.compare(posAbsolute, posAbsolute), 0);
 shouldBe(Temporal.Duration.compare(posAbsolute, zero), 1);
 shouldBe(Temporal.Duration.compare(zero, posAbsolute), -1);
 shouldBe(Temporal.Duration.compare('PT86400S', 'P1D'), 0);
+shouldBe(Temporal.Duration.compare({ days: 200 }, { days: 200, nanoseconds: 1 }), -1);
 
 shouldBe(Temporal.Duration.prototype.with.length, 1);
 shouldThrow(() => Temporal.Duration.prototype.with.call({}, { years: 1 }), TypeError);
@@ -188,6 +189,11 @@ for (const method of ['add', 'subtract']) {
 }
 shouldBe(Temporal.Duration.from('P1DT13H31M31S').add('P1DT13H31M31S').toString(), 'P3DT3H3M2S');
 shouldBe(Temporal.Duration.from('-PT1M59S').subtract('PT1M59S').toString(), '-PT3M58S');
+const duration1 = Temporal.Duration.from({microseconds: Number.MAX_SAFE_INTEGER + 1, nanoseconds: 0});
+const duration2 = Temporal.Duration.from({microseconds: -1, nanoseconds: -1000});
+shouldBe(duration1.subtract(duration2).toString(), 'PT9007199254.740994S');
+// Addition exceeds max duration
+shouldThrow(() => (new Temporal.Duration(0, 0, 0, 2, 0, 0, 0, 0, 0, 0)).add({ days: 104249991373 }), RangeError);
 
 shouldBe(Temporal.Duration.prototype.round.length, 1);
 shouldThrow(() => Temporal.Duration.prototype.round.call({}), TypeError);
@@ -220,6 +226,19 @@ shouldBe(Temporal.Duration.from('-PT31S').round({ smallestUnit: 'second', roundi
 shouldBe(Temporal.Duration.from('-PT31S').round({ smallestUnit: 'second', roundingIncrement: 30, roundingMode: 'floor' }).toString(), '-PT60S');
 shouldBe(Temporal.Duration.from('-PT45S').round({ smallestUnit: 'second', roundingIncrement: 30 }).toString(), '-PT60S');
 shouldBe(Temporal.Duration.from('-PT45S').round({ smallestUnit: 'second', roundingIncrement: 30, roundingMode: 'trunc' }).toString(), '-PT30S');
+// Rounding would exceed maxTimeDuration
+shouldThrow(() => Temporal.Duration.from({ seconds: Number.MAX_SAFE_INTEGER }).round({ smallestUnit: 'seconds', roundingMode: 'ceil', roundingIncrement: 30 }), RangeError);
+
+const seconds = 8692288669465520;
+const nanoseconds = 321_414_345;
+const d = new Temporal.Duration(0, 0, 0, 0, 0, 0, seconds, 0, 0, nanoseconds);
+const result = d.round({ largestUnit: "nanoseconds" });
+const expectedNanoseconds = Number(BigInt(seconds) * 1_000_000_000n + BigInt(nanoseconds));
+shouldBe(expectedNanoseconds, 8692288669465520_321_414_345);
+shouldBe(result.nanoseconds, expectedNanoseconds);
+
+// Rounding would exceed maxTimeDuration
+shouldThrow(() => Temporal.Duration.from({ seconds: Number.MAX_SAFE_INTEGER }).round({ smallestUnit: 'seconds', roundingMode: 'ceil', roundingIncrement: 30 }), RangeError);
 
 shouldBe(Temporal.Duration.prototype.total.length, 1);
 shouldThrow(() => Temporal.Duration.prototype.total.call({}), TypeError);
@@ -239,6 +258,10 @@ shouldBe(posAbsolute.total({ unit: 'milliseconds' }), 93784005.006007);
 shouldBe(posAbsolute.total({ unit: 'microseconds' }), 93784005006.007);
 shouldBe(posAbsolute.total({ unit: 'nanoseconds' }), 93784005006007);
 shouldBe(Temporal.Duration.from('-PT123456789S').total({ unit: 'day' }), -1428.8980208333332);
+const posSubseconds = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 999, 999999, 999999999);
+const negSubseconds = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, -999, -999999, -999999999);
+shouldBe(posSubseconds.total("seconds"), 2.998998999);
+shouldBe(negSubseconds.total("seconds"), -2.998998999);
 
 // At present, toLocaleString has the same behavior as toJSON or argumentless toString.
 for (const method of ['toString', 'toJSON', 'toLocaleString']) {    
@@ -291,5 +314,8 @@ shouldBe(pos.toString({ fractionalSecondDigits: 7, roundingMode: 'ceil' }), 'P1Y
 shouldBe(pos.toString({ fractionalSecondDigits: 2, roundingMode: 'floor' }), 'P1Y2M3W4DT5H6M7.00S');
 shouldBe(pos.toString({ fractionalSecondDigits: 2, roundingMode: 'halfExpand' }), 'P1Y2M3W4DT5H6M7.01S');
 
+const maxSeconds = Temporal.Duration.from({ seconds: Number.MAX_SAFE_INTEGER, milliseconds: 999 });
+shouldThrow(() => maxSeconds.toString({ smallestUnit: "seconds", roundingMode: "ceil" }), RangeError);
+
 shouldBe(Temporal.Duration.prototype.valueOf.length, 0);
 shouldThrow(() => new Temporal.Duration().valueOf(), TypeError);

JSTests/stress/temporal-instant.js

@@ -408,3 +408,25 @@ const maxValue = new Temporal.Instant(86400_0000_0000_000_000_000n);
         shouldThrow(() => epoch.subtract({ [unit]: -Number.MAX_VALUE }), RangeError);
     });
 }
+
+// since() and until()
+{
+    const earlier = Temporal.Instant.from("1976-11-18T15:23:30.123456789Z");
+    const later = Temporal.Instant.from("2019-10-29T10:46:38.271986102Z");
+    const diff = later.since(earlier);
+    shouldBe(diff.nanoseconds, 313);
+    shouldBe(diff.microseconds, 529);
+    shouldBe(diff.milliseconds, 148);
+    shouldBe(diff.seconds, 1355167388);
+    const diff1 = earlier.until(later);
+    shouldBe(diff1.nanoseconds, diff.nanoseconds);
+    shouldBe(diff1.microseconds, diff.microseconds);
+    shouldBe(diff1.milliseconds, diff.milliseconds);
+    shouldBe(diff1.seconds, diff.seconds);
+}
+
+// round()
+{
+    const pos = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 999, 999999, 999999999);
+    shouldBe(pos.round({ largestUnit: "seconds" }).seconds, 2);
+}

JSTests/stress/temporal-plaindate.js

@@ -414,7 +414,25 @@ shouldBe(Temporal.PlainDate.prototype.until.length, 1);
     shouldBe(date.since('2020-02-12', { largestUnit: 'week' }).toString(), 'P2W2D');
     shouldBe(date.until('2020-02-12', { largestUnit: 'week' }).toString(), '-P2W2D');
 
+    const earlier = Temporal.PlainDate.from("2019-01-08");
+    const later = Temporal.PlainDate.from("2021-09-07");
+    shouldBe(later.since(earlier, { smallestUnit: "years", roundingIncrement: 4, roundingMode: "halfExpand" }).toString(), "P4Y");
+    shouldBe(earlier.until(later, { smallestUnit: "years", roundingIncrement: 4, roundingMode: "halfExpand" }).toString(), "P4Y");
+
     shouldThrow(() => { date.until('2019-02-28', { smallestUnit: 'hour' }); }, RangeError);
     shouldThrow(() => { date.until('2019-02-28', { largestUnit: 'hour' }); }, RangeError);
     shouldThrow(() => { date.until('2019-02-28', { largestUnit: 'day', smallestUnit: 'month' }); }, RangeError);
 }
+
+{
+    shouldBe(new Temporal.PlainDate(2000, 5, 2, "iso8601").calendarId, "iso8601");
+}
+
+shouldBe(Temporal.PlainDate.prototype.toPlainMonthDay.length, 0);
+shouldBe(Temporal.PlainDate.prototype.toPlainYearMonth.length, 0);
+{
+    const date = Temporal.PlainDate.from('2020-02-28');
+
+    shouldBe(date.toPlainMonthDay().toString(), '02-28');
+    shouldBe(date.toPlainYearMonth().toString(), '2020-02');
+}

JSTests/stress/temporal-plainmonthday.js

@@ -0,0 +1,116 @@
+//@ requireOptions("--useTemporal=1")
+
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`expected ${expected} but got ${actual}`);
+}
+
+function shouldThrow(func, errorType, message) {
+    let error;
+    try {
+        func();
+    } catch (e) {
+        error = e;
+    }
+
+    if (!(error instanceof errorType))
+        throw new Error(`Expected ${errorType.name}!`);
+    if (message !== undefined)
+        shouldBe(String(error), message);
+}
+
+shouldBe(Temporal.PlainMonthDay instanceof Function, true);
+shouldBe(Temporal.PlainMonthDay.length, 2);
+shouldBe(Object.getOwnPropertyDescriptor(Temporal.PlainMonthDay, 'prototype').writable, false);
+shouldBe(Object.getOwnPropertyDescriptor(Temporal.PlainMonthDay, 'prototype').enumerable, false);
+shouldBe(Object.getOwnPropertyDescriptor(Temporal.PlainMonthDay, 'prototype').configurable, false);
+shouldBe(Temporal.PlainMonthDay.prototype.constructor, Temporal.PlainMonthDay);
+
+const monthDay = new Temporal.PlainMonthDay(4, 29);
+
+{
+    shouldBe(monthDay.monthCode, "M04");
+    shouldBe(monthDay.day, 29);
+    shouldBe(monthDay.year, undefined);
+    shouldBe(monthDay.calendarId, "iso8601");
+
+    shouldThrow(() => new Temporal.PlainMonthDay(20, 1), RangeError);
+    shouldThrow(() => new Temporal.PlainMonthDay(1, 40), RangeError);
+}
+
+{
+    shouldBe(monthDay.toString(), '04-29');
+    shouldBe(monthDay.toJSON(), monthDay.toString());
+    shouldBe(monthDay.toLocaleString(), monthDay.toString());
+}
+
+shouldBe(Temporal.PlainMonthDay.prototype.with.length, 1);
+{
+    shouldBe(monthDay.with({ year: 2021, month: 3, day: 5 }).toString(), '03-05');
+    shouldBe(monthDay.with({ month: 3, day: 5 }).toString(), '03-05');
+    shouldBe(monthDay.with({ month: 3 }).toString(), '03-29');
+    shouldBe(monthDay.with({ day: 5 }).toString(), '04-05');
+
+    shouldBe(monthDay.with({ day: 31 }).toString(), '04-30');
+    shouldThrow(() => { monthDay.with({ day: 31 }, { overflow: 'reject' }); }, RangeError);
+}
+
+{
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09t03:24:30')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09 03:24:30')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+20:20:59')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30-20:20:59')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+10')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+1020')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+102030')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+10:20:30.05')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+10:20:30.123456789')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09T03:24:30+01:00[Europe/Brussels]')), `01-09`);
+    shouldBe(String(Temporal.PlainMonthDay.from('2007-01-09 03:24:30+01:00[Europe/Brussels]')), `01-09`);
+
+    let monthDay1 = Temporal.PlainMonthDay.from('2007-04-29T03:24:30+01:00[Europe/Brussels]');
+    shouldBe(monthDay1 === Temporal.PlainMonthDay.from(monthDay1), false);
+    shouldBe(monthDay1.toString(), Temporal.PlainMonthDay.from(monthDay1).toString());
+
+    shouldBe(Temporal.PlainMonthDay.from({ year: 2007, month: 4, day: 29 }).toString(), monthDay.toString());
+    shouldBe(Temporal.PlainMonthDay.from({ year: 2007, monthCode: 'M04', day: 29 }).toString(), monthDay.toString());
+
+    shouldBe(Temporal.PlainMonthDay.from({ year: 2007, month: 20, day: 40 }).toString(), '12-31');
+    shouldThrow(() => Temporal.PlainMonthDay.from({ year: 2007, month: 20, day: 40 }, { overflow: 'reject' }), RangeError);
+
+    shouldBe(Temporal.PlainMonthDay.from({ month: 4, day: 29 }).toString(), monthDay.toString());
+    shouldBe(Temporal.PlainMonthDay.from({ monthCode: 'M04', day: 29 }).toString(), monthDay.toString());
+
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ year: 2007, day: 9 }); }, TypeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ year: 2007, month: 1 }); }, TypeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ month: Infinity, day: 9 }); }, RangeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ month: 0, day: 9 }); }, RangeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ monthCode: 'M00', day: 9 }); }, RangeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ month: 1, day: 0 }); }, RangeError);
+    shouldThrow(() => { Temporal.PlainMonthDay.from({ month: 1, monthCode: 'M02', day: 9 }); }, RangeError);
+}
+
+shouldBe(Temporal.PlainMonthDay.prototype.equals.length, 1);
+{
+    const ones = new Temporal.PlainMonthDay(1,1);
+    shouldBe(ones.equals(new Temporal.PlainMonthDay(1,1)), true);
+    shouldBe(ones.equals(new Temporal.PlainMonthDay(2,1)), false);
+    shouldBe(ones.equals(new Temporal.PlainMonthDay(1,2)), false);
+}
+
+shouldBe(Temporal.PlainMonthDay.prototype.toPlainDate.length, 1);
+{
+    shouldBe(monthDay.toPlainDate({ year: 2025 }).toString(), "2025-04-29");
+    shouldThrow(() => monthDay.toPlainDate({ notYear: 'whatever' }), TypeError);
+    const leapDay = new Temporal.PlainMonthDay(2, 29);
+    shouldBe(leapDay.toPlainDate({ year: 2020 }).toString(), "2020-02-29");
+    shouldBe(leapDay.toPlainDate({ year: 2025 }).toString(), "2025-02-28");
+
+}
+
+shouldBe(Temporal.PlainMonthDay.prototype.valueOf.length, 0);
+{
+    shouldThrow(() => monthDay.valueOf(), TypeError);
+}