diff --git a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp index f0e1fce7a79..2c6df2e0d22 100644 --- a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp +++ b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp @@ -5,6 +5,7 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include #include #include #include @@ -37,6 +38,7 @@ void InstantPrototype::initialize(Realm& realm) define_native_function(realm, vm.names.subtract, subtract, 1, attr); define_native_function(realm, vm.names.until, until, 1, attr); define_native_function(realm, vm.names.since, since, 1, attr); + define_native_function(realm, vm.names.round, round, 1, attr); define_native_function(realm, vm.names.equals, equals, 1, attr); define_native_function(realm, vm.names.toString, to_string, 0, attr); define_native_function(realm, vm.names.toLocaleString, to_locale_string, 0, attr); @@ -126,6 +128,99 @@ JS_DEFINE_NATIVE_FUNCTION(InstantPrototype::since) return TRY(difference_temporal_instant(vm, DurationOperation::Since, instant, other, options)); } +// 8.3.9 Temporal.Instant.prototype.round ( roundTo ), https://tc39.es/proposal-temporal/#sec-temporal.instant.prototype.round +JS_DEFINE_NATIVE_FUNCTION(InstantPrototype::round) +{ + auto& realm = *vm.current_realm(); + + auto round_to_value = vm.argument(0); + + // 1. Let instant be the this value. + // 2. Perform ? RequireInternalSlot(instant, [[InitializedTemporalInstant]]). + auto instant = TRY(typed_this_object(vm)); + + // 3. If roundTo is undefined, then + if (round_to_value.is_undefined()) { + // a. Throw a TypeError exception. + return vm.throw_completion(ErrorType::TemporalMissingOptionsObject); + } + + GC::Ptr round_to; + + // 4. If roundTo is a String, then + if (round_to_value.is_string()) { + // a. Let paramString be roundTo. + auto param_string = round_to_value; + + // b. Set roundTo to OrdinaryObjectCreate(null). + round_to = Object::create(realm, nullptr); + + // c. Perform ! CreateDataPropertyOrThrow(roundTo, "smallestUnit", paramString). + MUST(round_to->create_data_property_or_throw(vm.names.smallestUnit, param_string)); + } + // 5. Else, + else { + // a. Set roundTo to ? GetOptionsObject(roundTo). + round_to = TRY(get_options_object(vm, round_to_value)); + } + + // 6. NOTE: The following steps read options and perform independent validation in alphabetical order + // (GetRoundingIncrementOption reads "roundingIncrement" and GetRoundingModeOption reads "roundingMode"). + + // 7. Let roundingIncrement be ? GetRoundingIncrementOption(roundTo). + auto rounding_increment = TRY(get_rounding_increment_option(vm, *round_to)); + + // 8. Let roundingMode be ? GetRoundingModeOption(roundTo, HALF-EXPAND). + auto rounding_mode = TRY(get_rounding_mode_option(vm, *round_to, RoundingMode::HalfExpand)); + + // 9. Let smallestUnit be ? GetTemporalUnitValuedOption(roundTo, "smallestUnit", TIME, REQUIRED). + auto smallest_unit = TRY(get_temporal_unit_valued_option(vm, *round_to, vm.names.smallestUnit, UnitGroup::Time, Required {})); + auto smallest_unit_value = smallest_unit.get(); + + auto maximum = [&]() { + switch (smallest_unit_value) { + // 10. If smallestUnit is hour, then + case Unit::Hour: + // a. Let maximum be HoursPerDay. + return hours_per_day; + // 11. Else if smallestUnit is minute, then + case Unit::Minute: + // a. Let maximum be MinutesPerHour × HoursPerDay. + return minutes_per_hour * hours_per_day; + // 12. Else if smallestUnit is second, then + case Unit::Second: + // a. Let maximum be SecondsPerMinute × MinutesPerHour × HoursPerDay. + return seconds_per_minute * minutes_per_hour * hours_per_day; + // 13. Else if smallestUnit is millisecond, then + case Unit::Millisecond: + // a. Let maximum be ℝ(msPerDay). + return ms_per_day; + // 14. Else if smallestUnit is microsecond, then + case Unit::Microsecond: + // a. Let maximum be 10**3 × ℝ(msPerDay). + return 1000 * ms_per_day; + // 15. Else, + case Unit::Nanosecond: + // a. Assert: smallestUnit is nanosecond. + // b. Let maximum be nsPerDay. + return ns_per_day; + default: + break; + } + + VERIFY_NOT_REACHED(); + }(); + + // 16. Perform ? ValidateTemporalRoundingIncrement(roundingIncrement, maximum, true). + TRY(validate_temporal_rounding_increment(vm, rounding_increment, maximum, true)); + + // 17. Let roundedNs be RoundTemporalInstant(instant.[[EpochNanoseconds]], roundingIncrement, smallestUnit, roundingMode). + auto rounded_nanoseconds = round_temporal_instant(instant->epoch_nanoseconds()->big_integer(), rounding_increment, smallest_unit_value, rounding_mode); + + // 18. Return ! CreateTemporalInstant(roundedNs). + return MUST(create_temporal_instant(vm, BigInt::create(vm, move(rounded_nanoseconds)))); +} + // 8.3.10 Temporal.Instant.prototype.equals ( other ), https://tc39.es/proposal-temporal/#sec-temporal.instant.prototype.equals JS_DEFINE_NATIVE_FUNCTION(InstantPrototype::equals) { diff --git a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h index f2d72ec9713..bdd2f57613c 100644 --- a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h +++ b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h @@ -29,6 +29,7 @@ private: JS_DECLARE_NATIVE_FUNCTION(subtract); JS_DECLARE_NATIVE_FUNCTION(until); JS_DECLARE_NATIVE_FUNCTION(since); + JS_DECLARE_NATIVE_FUNCTION(round); JS_DECLARE_NATIVE_FUNCTION(equals); JS_DECLARE_NATIVE_FUNCTION(to_string); JS_DECLARE_NATIVE_FUNCTION(to_locale_string); diff --git a/Libraries/LibJS/Tests/builtins/Temporal/Instant/Instant.prototype.round.js b/Libraries/LibJS/Tests/builtins/Temporal/Instant/Instant.prototype.round.js new file mode 100644 index 00000000000..2643c96fb39 --- /dev/null +++ b/Libraries/LibJS/Tests/builtins/Temporal/Instant/Instant.prototype.round.js @@ -0,0 +1,109 @@ +describe("correct behavior", () => { + test("length is 1", () => { + expect(Temporal.Instant.prototype.round).toHaveLength(1); + }); + + test("basic functionality", () => { + const instant = new Temporal.Instant(1111111111111n); + expect(instant.round({ smallestUnit: "second" }).epochNanoseconds).toBe(1111000000000n); + expect( + instant.round({ smallestUnit: "second", roundingMode: "ceil" }).epochNanoseconds + ).toBe(1112000000000n); + expect( + instant.round({ smallestUnit: "minute", roundingIncrement: 30, roundingMode: "floor" }) + .epochNanoseconds + ).toBe(0n); + expect( + instant.round({ + smallestUnit: "minute", + roundingIncrement: 30, + roundingMode: "halfExpand", + }).epochNanoseconds + ).toBe(1800000000000n); + }); + + test("smallest unit", () => { + const instant = new Temporal.Instant(1732488841234567891n); + + const tests = [ + { smallestUnit: "hour", floor: 1732485600000000000n, ceil: 1732489200000000000n }, + { smallestUnit: "minute", floor: 1732488840000000000n, ceil: 1732488900000000000n }, + { smallestUnit: "second", floor: 1732488841000000000n, ceil: 1732488842000000000n }, + { + smallestUnit: "millisecond", + floor: 1732488841234000000n, + ceil: 1732488841235000000n, + }, + { + smallestUnit: "microsecond", + floor: 1732488841234567000n, + ceil: 1732488841234568000n, + }, + { smallestUnit: "nanosecond", floor: 1732488841234567891n, ceil: 1732488841234567891n }, + ]; + + for (const { smallestUnit, floor, ceil } of tests) { + let result = instant.round({ smallestUnit, roundingMode: "floor" }); + expect(result.epochNanoseconds).toBe(floor); + + result = instant.round({ smallestUnit, roundingMode: "ceil" }); + expect(result.epochNanoseconds).toBe(ceil); + } + }); + + test("string argument is implicitly converted to options object", () => { + const instant = new Temporal.Instant(1111111111111n); + expect( + instant.round("second").equals(instant.round({ smallestUnit: "second" })) + ).toBeTrue(); + }); +}); + +describe("errors", () => { + test("this value must be a Temporal.Instant object", () => { + expect(() => { + Temporal.Instant.prototype.round.call("foo", {}); + }).toThrowWithMessage(TypeError, "Not an object of type Temporal.Instant"); + }); + + test("missing options object", () => { + expect(() => { + const instant = new Temporal.Instant(1n); + instant.round(); + }).toThrowWithMessage(TypeError, "Required options object is missing or undefined"); + }); + + test("invalid rounding mode", () => { + expect(() => { + const instant = new Temporal.Instant(1n); + instant.round({ smallestUnit: "second", roundingMode: "serenityOS" }); + }).toThrowWithMessage(RangeError, "is not a valid value for option roundingMode"); + }); + + test("invalid smallest unit", () => { + expect(() => { + const instant = new Temporal.Instant(1n); + instant.round({ smallestUnit: "serenityOS" }); + }).toThrowWithMessage(RangeError, "is not a valid value for option smallestUnit"); + }); + + test("increment may not be NaN", () => { + expect(() => { + const instant = new Temporal.Instant(1n); + instant.round({ smallestUnit: "second", roundingIncrement: NaN }); + }).toThrowWithMessage(RangeError, "is not a valid value for option roundingIncrement"); + }); + + test("increment may smaller than 1 or larger than maximum", () => { + const instant = new Temporal.Instant(1n); + expect(() => { + instant.round({ smallestUnit: "second", roundingIncrement: -1 }); + }).toThrowWithMessage(RangeError, "is not a valid value for option roundingIncrement"); + expect(() => { + instant.round({ smallestUnit: "second", roundingIncrement: 0 }); + }).toThrowWithMessage(RangeError, "is not a valid value for option roundingIncrement"); + expect(() => { + instant.round({ smallestUnit: "second", roundingIncrement: Infinity }); + }).toThrowWithMessage(RangeError, "is not a valid value for option roundingIncrement"); + }); +});