LibJS: Disallow one day long time zone offsets

This is a normative change in the Temporal spec.
See: 9cc8b29b

Userland/Libraries/LibJS/Runtime/ErrorTypes.h

@@ -246,7 +246,8 @@
     M(TemporalInvalidMonthCode, "Invalid month code")                                                                                   \
     M(TemporalInvalidMonthDayString, "Invalid month day string '{}'")                                                                   \
     M(TemporalInvalidMonthDayStringUTCDesignator, "Invalid month day string '{}': must not contain a UTC designator")                   \
-    M(TemporalInvalidOffsetNanosecondsValue, "Invalid offset nanoseconds value, must be in range -86400 * 10^9 to 86400 * 10^9")        \
+    M(TemporalInvalidOffsetNanosecondsValue, "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to "                 \
+                                             "86400 * 10^9 - 1")                                                                        \
     M(TemporalInvalidPlainDate, "Invalid plain date")                                                                                   \
     M(TemporalInvalidPlainDateTime, "Invalid plain date time")                                                                          \
     M(TemporalInvalidPlainMonthDay, "Invalid plain month day")                                                                          \

Userland/Libraries/LibJS/Runtime/Temporal/TimeZone.cpp

@@ -492,8 +492,8 @@ ThrowCompletionOr<double> get_offset_nanoseconds_for(VM& vm, Value time_zone, In
     // 5. Set offsetNanoseconds to ℝ(offsetNanoseconds).
     auto offset_nanoseconds = offset_nanoseconds_value.as_double();
 
-    // 6. If abs(offsetNanoseconds) > nsPerDay, throw a RangeError exception.
+    // 6. If abs(offsetNanoseconds) ≥ nsPerDay, throw a RangeError exception.
-    if (fabs(offset_nanoseconds) > ns_per_day)
+    if (fabs(offset_nanoseconds) >= ns_per_day)
         return vm.throw_completion<RangeError>(ErrorType::TemporalInvalidOffsetNanosecondsValue);
 
     // 7. Return offsetNanoseconds.

Userland/Libraries/LibJS/Tests/builtins/Temporal/Now/Now.plainDate.js

@@ -14,7 +14,7 @@ describe("correct behavior", () => {
         const calendar = new Temporal.Calendar("iso8601");
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return 86400000000000;
+                return 86399999999999;
             },
         };
         const plainDate = Temporal.Now.plainDate(calendar, "UTC");
@@ -34,6 +34,21 @@ describe("correct behavior", () => {
             }
         }
     });
+
+    test("cannot have a time zone with more than a day", () => {
+        [86400000000000, -86400000000000, 86400000000001, 86400000000002].forEach(offset => {
+            const calendar = new Temporal.Calendar("iso8601");
+            const timeZone = {
+                getOffsetNanosecondsFor() {
+                    return offset;
+                },
+            };
+            expect(() => Temporal.Now.plainDate(calendar, timeZone)).toThrowWithMessage(
+                RangeError,
+                "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to 86400 * 10^9 - 1"
+            );
+        });
+    });
 });
 
 describe("errors", () => {

Userland/Libraries/LibJS/Tests/builtins/Temporal/Now/Now.plainDateISO.js

@@ -12,7 +12,7 @@ describe("correct behavior", () => {
     test("custom time zone", () => {
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return 86400000000000;
+                return 86399999999999;
             },
         };
         const plainDate = Temporal.Now.plainDateISO("UTC");
@@ -32,6 +32,20 @@ describe("correct behavior", () => {
             }
         }
     });
+
+    test("cannot have a time zone with more than a day", () => {
+        [86400000000000, -86400000000000, 86400000000001, 86400000000002].forEach(offset => {
+            const timeZone = {
+                getOffsetNanosecondsFor() {
+                    return offset;
+                },
+            };
+            expect(() => Temporal.Now.plainDateISO(timeZone)).toThrowWithMessage(
+                RangeError,
+                "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to 86400 * 10^9 - 1"
+            );
+        });
+    });
 });
 
 describe("errors", () => {

Userland/Libraries/LibJS/Tests/builtins/Temporal/Now/Now.plainDateTime.js

@@ -33,7 +33,7 @@ describe("correct behavior", () => {
         const calendar = new Temporal.Calendar("iso8601");
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return 86400000000000;
+                return 86399999999999;
             },
         };
 
@@ -54,7 +54,7 @@ describe("correct behavior", () => {
         const calendar = new Temporal.Calendar("iso8601");
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return -86400000000000;
+                return -86399999999999;
             },
         };
 
@@ -72,6 +72,21 @@ describe("correct behavior", () => {
     });
 
     expect(timeZoneTested).toBeTrue();
+
+    test("cannot have a time zone with more than a day", () => {
+        [86400000000000, -86400000000000, 86400000000001, 86400000000002].forEach(offset => {
+            const calendar = new Temporal.Calendar("iso8601");
+            const timeZone = {
+                getOffsetNanosecondsFor() {
+                    return offset;
+                },
+            };
+            expect(() => Temporal.Now.plainDateTime(calendar, timeZone)).toThrowWithMessage(
+                RangeError,
+                "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to 86400 * 10^9 - 1"
+            );
+        });
+    });
 });
 
 describe("errors", () => {

Userland/Libraries/LibJS/Tests/builtins/Temporal/Now/Now.plainDateTimeISO.js

@@ -31,7 +31,7 @@ describe("correct behavior", () => {
     test("custom time zone positive", () => {
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return 86400000000000;
+                return 86399999999999;
             },
         };
 
@@ -51,7 +51,7 @@ describe("correct behavior", () => {
     test("custom time zone negative", () => {
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return -86400000000000;
+                return -86399999999999;
             },
         };
 
@@ -69,6 +69,20 @@ describe("correct behavior", () => {
     });
 
     expect(timeZoneTested).toBeTrue();
+
+    test("cannot have a time zone with more than a day", () => {
+        [86400000000000, -86400000000000, 86400000000001, 86400000000002].forEach(offset => {
+            const timeZone = {
+                getOffsetNanosecondsFor() {
+                    return offset;
+                },
+            };
+            expect(() => Temporal.Now.plainDateTimeISO(timeZone)).toThrowWithMessage(
+                RangeError,
+                "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to 86400 * 10^9 - 1"
+            );
+        });
+    });
 });
 
 describe("errors", () => {

Userland/Libraries/LibJS/Tests/builtins/Temporal/Now/Now.plainTimeISO.js

@@ -12,13 +12,27 @@ describe("correct behavior", () => {
     test("custom time zone", () => {
         const timeZone = {
             getOffsetNanosecondsFor() {
-                return 86400000000000;
+                return 86399999999999;
             },
         };
         const plainTime = Temporal.Now.plainTimeISO("UTC");
         const plainTimeWithOffset = Temporal.Now.plainTimeISO(timeZone);
         // FIXME: Compare these in a sensible way
     });
+
+    test("cannot have a time zone with more than a day", () => {
+        [86400000000000, -86400000000000, 86400000000001, 86400000000002].forEach(offset => {
+            const timeZone = {
+                getOffsetNanosecondsFor() {
+                    return offset;
+                },
+            };
+            expect(() => Temporal.Now.plainTimeISO(timeZone)).toThrowWithMessage(
+                RangeError,
+                "Invalid offset nanoseconds value, must be in range -86400 * 10^9 + 1 to 86400 * 10^9 - 1"
+            );
+        });
+    });
 });
 
 describe("errors", () => {