566 lines
25 KiB
C++
566 lines
25 KiB
C++
/*
|
||
* Copyright (c) 2021, Idan Horowitz <idan.horowitz@serenityos.org>
|
||
* Copyright (c) 2021, Linus Groh <linusg@serenityos.org>
|
||
*
|
||
* SPDX-License-Identifier: BSD-2-Clause
|
||
*/
|
||
|
||
#include <LibJS/Runtime/AbstractOperations.h>
|
||
#include <LibJS/Runtime/GlobalObject.h>
|
||
#include <LibJS/Runtime/Object.h>
|
||
#include <LibJS/Runtime/Temporal/AbstractOperations.h>
|
||
#include <LibJS/Runtime/Temporal/Calendar.h>
|
||
#include <LibJS/Runtime/Temporal/Instant.h>
|
||
#include <LibJS/Runtime/Temporal/PlainDateTime.h>
|
||
#include <LibJS/Runtime/Temporal/PlainTime.h>
|
||
#include <LibJS/Runtime/Temporal/PlainTimeConstructor.h>
|
||
#include <LibJS/Runtime/Temporal/TimeZone.h>
|
||
#include <LibJS/Runtime/Temporal/ZonedDateTime.h>
|
||
|
||
namespace JS::Temporal {
|
||
|
||
// 4 Temporal.PlainTime Objects, https://tc39.es/proposal-temporal/#sec-temporal-plaintime-objects
|
||
PlainTime::PlainTime(u8 iso_hour, u8 iso_minute, u8 iso_second, u16 iso_millisecond, u16 iso_microsecond, u16 iso_nanosecond, Calendar& calendar, Object& prototype)
|
||
: Object(prototype)
|
||
, m_iso_hour(iso_hour)
|
||
, m_iso_minute(iso_minute)
|
||
, m_iso_second(iso_second)
|
||
, m_iso_millisecond(iso_millisecond)
|
||
, m_iso_microsecond(iso_microsecond)
|
||
, m_iso_nanosecond(iso_nanosecond)
|
||
, m_calendar(calendar)
|
||
{
|
||
}
|
||
|
||
void PlainTime::visit_edges(Visitor& visitor)
|
||
{
|
||
Base::visit_edges(visitor);
|
||
visitor.visit(&m_calendar);
|
||
}
|
||
|
||
// 4.5.2 ToTemporalTime ( item [ , overflow ] ), https://tc39.es/proposal-temporal/#sec-temporal-totemporaltime
|
||
ThrowCompletionOr<PlainTime*> to_temporal_time(GlobalObject& global_object, Value item, Optional<StringView> overflow)
|
||
{
|
||
auto& vm = global_object.vm();
|
||
|
||
// 1. If overflow is not present, set it to "constrain".
|
||
if (!overflow.has_value())
|
||
overflow = "constrain"sv;
|
||
|
||
// 2. Assert: overflow is either "constrain" or "reject".
|
||
VERIFY(overflow == "constrain"sv || overflow == "reject"sv);
|
||
|
||
Optional<TemporalTime> result;
|
||
|
||
// 3. If Type(item) is Object, then
|
||
if (item.is_object()) {
|
||
auto& item_object = item.as_object();
|
||
|
||
// a. If item has an [[InitializedTemporalTime]] internal slot, then
|
||
if (is<PlainTime>(item_object)) {
|
||
// i. Return item.
|
||
return &static_cast<PlainTime&>(item_object);
|
||
}
|
||
|
||
// b. If item has an [[InitializedTemporalZonedDateTime]] internal slot, then
|
||
if (is<ZonedDateTime>(item_object)) {
|
||
auto& zoned_date_time = static_cast<ZonedDateTime&>(item_object);
|
||
// i. Let instant be ! CreateTemporalInstant(item.[[Nanoseconds]]).
|
||
auto* instant = create_temporal_instant(global_object, zoned_date_time.nanoseconds()).release_value();
|
||
// ii. Set plainDateTime to ? BuiltinTimeZoneGetPlainDateTimeFor(item.[[TimeZone]], instant, item.[[Calendar]]).
|
||
auto* plain_date_time = TRY(builtin_time_zone_get_plain_date_time_for(global_object, &zoned_date_time.time_zone(), *instant, zoned_date_time.calendar()));
|
||
// iii. Return ! CreateTemporalTime(plainDateTime.[[ISOHour]], plainDateTime.[[ISOMinute]], plainDateTime.[[ISOSecond]], plainDateTime.[[ISOMillisecond]], plainDateTime.[[ISOMicrosecond]], plainDateTime.[[ISONanosecond]]).
|
||
return TRY(create_temporal_time(global_object, plain_date_time->iso_hour(), plain_date_time->iso_minute(), plain_date_time->iso_second(), plain_date_time->iso_millisecond(), plain_date_time->iso_microsecond(), plain_date_time->iso_nanosecond()));
|
||
}
|
||
|
||
// c. If item has an [[InitializedTemporalDateTime]] internal slot, then
|
||
if (is<PlainDateTime>(item_object)) {
|
||
auto& plain_date_time = static_cast<PlainDateTime&>(item_object);
|
||
// i. Return ! CreateTemporalTime(item.[[ISOHour]], item.[[ISOMinute]], item.[[ISOSecond]], item.[[ISOMillisecond]], item.[[ISOMicrosecond]], item.[[ISONanosecond]]).
|
||
return TRY(create_temporal_time(global_object, plain_date_time.iso_hour(), plain_date_time.iso_minute(), plain_date_time.iso_second(), plain_date_time.iso_millisecond(), plain_date_time.iso_microsecond(), plain_date_time.iso_nanosecond()));
|
||
}
|
||
|
||
// d. Let calendar be ? GetTemporalCalendarWithISODefault(item).
|
||
auto* calendar = TRY(get_temporal_calendar_with_iso_default(global_object, item_object));
|
||
|
||
// e. If ? ToString(calendar) is not "iso8601", then
|
||
auto calendar_identifier = Value(calendar).to_string(global_object);
|
||
if (auto* exception = vm.exception())
|
||
return throw_completion(exception->value());
|
||
if (calendar_identifier != "iso8601"sv) {
|
||
// i. Throw a RangeError exception.
|
||
return vm.throw_completion<RangeError>(global_object, ErrorType::TemporalInvalidCalendarIdentifier, calendar_identifier);
|
||
}
|
||
|
||
// f. Let result be ? ToTemporalTimeRecord(item).
|
||
auto unregulated_result = TRY(to_temporal_time_record(global_object, item_object));
|
||
|
||
// g. Set result to ? RegulateTime(result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]], overflow).
|
||
result = TRY(regulate_time(global_object, unregulated_result.hour, unregulated_result.minute, unregulated_result.second, unregulated_result.millisecond, unregulated_result.microsecond, unregulated_result.nanosecond, *overflow));
|
||
}
|
||
// 4. Else,
|
||
else {
|
||
// a. Let string be ? ToString(item).
|
||
auto string = item.to_string(global_object);
|
||
if (auto* exception = vm.exception())
|
||
return throw_completion(exception->value());
|
||
|
||
// b. Let result be ? ParseTemporalTimeString(string).
|
||
result = TRY(parse_temporal_time_string(global_object, string));
|
||
|
||
// c. Assert: ! IsValidTime(result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]]) is true.
|
||
VERIFY(is_valid_time(result->hour, result->minute, result->second, result->millisecond, result->microsecond, result->nanosecond));
|
||
|
||
// d. If result.[[Calendar]] is not one of undefined or "iso8601", then
|
||
if (result->calendar.has_value() && *result->calendar != "iso8601"sv) {
|
||
// i. Throw a RangeError exception.
|
||
return vm.throw_completion<RangeError>(global_object, ErrorType::TemporalInvalidCalendarIdentifier, *result->calendar);
|
||
}
|
||
}
|
||
|
||
// 5. Return ? CreateTemporalTime(result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]]).
|
||
return TRY(create_temporal_time(global_object, result->hour, result->minute, result->second, result->millisecond, result->microsecond, result->nanosecond));
|
||
}
|
||
|
||
// 4.5.3 ToPartialTime ( temporalTimeLike ), https://tc39.es/proposal-temporal/#sec-temporal-topartialtime
|
||
ThrowCompletionOr<PartialUnregulatedTemporalTime> to_partial_time(GlobalObject& global_object, Object& temporal_time_like)
|
||
{
|
||
auto& vm = global_object.vm();
|
||
|
||
// 1. Assert: Type(temporalTimeLike) is Object.
|
||
|
||
// 2. Let result be the Record { [[Hour]]: undefined, [[Minute]]: undefined, [[Second]]: undefined, [[Millisecond]]: undefined, [[Microsecond]]: undefined, [[Nanosecond]]: undefined }.
|
||
auto result = PartialUnregulatedTemporalTime {};
|
||
|
||
// 3. Let any be false.
|
||
bool any = false;
|
||
|
||
// 4. For each row of Table 3, except the header row, in table order, do
|
||
for (auto& [internal_slot, property] : temporal_time_like_properties<PartialUnregulatedTemporalTime, Optional<double>>(vm)) {
|
||
// a. Let property be the Property value of the current row.
|
||
|
||
// b. Let value be ? Get(temporalTimeLike, property).
|
||
auto value = temporal_time_like.get(property);
|
||
if (auto* exception = vm.exception())
|
||
return throw_completion(exception->value());
|
||
|
||
// c. If value is not undefined, then
|
||
if (!value.is_undefined()) {
|
||
// i. Set any to true.
|
||
any = true;
|
||
|
||
// ii. Set value to ? ToIntegerThrowOnInfinity(value).
|
||
auto value_number = TRY(to_integer_throw_on_infinity(global_object, value, ErrorType::TemporalPropertyMustBeFinite));
|
||
|
||
// iii. Set result's internal slot whose name is the Internal Slot value of the current row to value.
|
||
result.*internal_slot = value_number;
|
||
}
|
||
}
|
||
|
||
// 5. If any is false, then
|
||
if (!any) {
|
||
// a. Throw a TypeError exception.
|
||
return vm.throw_completion<TypeError>(global_object, ErrorType::TemporalInvalidPlainTimeLikeObject);
|
||
}
|
||
|
||
// 6. Return result.
|
||
return result;
|
||
}
|
||
|
||
// 4.5.4 RegulateTime ( hour, minute, second, millisecond, microsecond, nanosecond, overflow ), https://tc39.es/proposal-temporal/#sec-temporal-regulatetime
|
||
ThrowCompletionOr<TemporalTime> regulate_time(GlobalObject& global_object, double hour, double minute, double second, double millisecond, double microsecond, double nanosecond, StringView overflow)
|
||
{
|
||
auto& vm = global_object.vm();
|
||
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond and nanosecond are integers.
|
||
// NOTE: As the spec is currently written this assertion can fail, these are either integers _or_ infinity.
|
||
// See https://github.com/tc39/proposal-temporal/issues/1672.
|
||
|
||
// 2. Assert: overflow is either "constrain" or "reject".
|
||
// NOTE: Asserted by the VERIFY_NOT_REACHED at the end
|
||
|
||
// 3. If overflow is "constrain", then
|
||
if (overflow == "constrain"sv) {
|
||
// a. Return ! ConstrainTime(hour, minute, second, millisecond, microsecond, nanosecond).
|
||
return constrain_time(hour, minute, second, millisecond, microsecond, nanosecond);
|
||
}
|
||
|
||
// 4. If overflow is "reject", then
|
||
if (overflow == "reject"sv) {
|
||
// a. If ! IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond) is false, throw a RangeError exception.
|
||
if (!is_valid_time(hour, minute, second, millisecond, microsecond, nanosecond))
|
||
return vm.throw_completion<RangeError>(global_object, ErrorType::TemporalInvalidPlainTime);
|
||
|
||
// b. Return the Record { [[Hour]]: hour, [[Minute]]: minute, [[Second]]: second, [[Millisecond]]: millisecond, [[Microsecond]]: microsecond, [[Nanosecond]]: nanosecond }.
|
||
return TemporalTime { .hour = static_cast<u8>(hour), .minute = static_cast<u8>(minute), .second = static_cast<u8>(second), .millisecond = static_cast<u16>(millisecond), .microsecond = static_cast<u16>(microsecond), .nanosecond = static_cast<u16>(nanosecond) };
|
||
}
|
||
|
||
VERIFY_NOT_REACHED();
|
||
}
|
||
|
||
// 4.5.5 IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond ), https://tc39.es/proposal-temporal/#sec-temporal-isvalidtime
|
||
bool is_valid_time(double hour, double minute, double second, double millisecond, double microsecond, double nanosecond)
|
||
{
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond, and nanosecond are integers.
|
||
|
||
// 2. If hour < 0 or hour > 23, then
|
||
if (hour > 23) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 3. If minute < 0 or minute > 59, then
|
||
if (minute > 59) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 4. If second < 0 or second > 59, then
|
||
if (second > 59) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 5. If millisecond < 0 or millisecond > 999, then
|
||
if (millisecond > 999) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 6. If microsecond < 0 or microsecond > 999, then
|
||
if (microsecond > 999) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 7. If nanosecond < 0 or nanosecond > 999, then
|
||
if (nanosecond > 999) {
|
||
// a. Return false.
|
||
return false;
|
||
}
|
||
|
||
// 8. Return true.
|
||
return true;
|
||
}
|
||
|
||
// 4.5.6 BalanceTime ( hour, minute, second, millisecond, microsecond, nanosecond ), https://tc39.es/proposal-temporal/#sec-temporal-balancetime
|
||
DaysAndTime balance_time(i64 hour, i64 minute, i64 second, i64 millisecond, i64 microsecond, i64 nanosecond)
|
||
{
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond, and nanosecond are integers.
|
||
|
||
// 2. Set microsecond to microsecond + floor(nanosecond / 1000).
|
||
microsecond += nanosecond / 1000;
|
||
|
||
// 3. Set nanosecond to nanosecond modulo 1000.
|
||
nanosecond %= 1000;
|
||
|
||
// 4. Set millisecond to millisecond + floor(microsecond / 1000).
|
||
millisecond += microsecond / 1000;
|
||
|
||
// 5. Set microsecond to microsecond modulo 1000.
|
||
microsecond %= 1000;
|
||
|
||
// 6. Set second to second + floor(millisecond / 1000).
|
||
second += millisecond / 1000;
|
||
|
||
// 7. Set millisecond to millisecond modulo 1000.
|
||
millisecond %= 1000;
|
||
|
||
// 8. Set minute to minute + floor(second / 60).
|
||
minute += second / 60;
|
||
|
||
// 9. Set second to second modulo 60.
|
||
second %= 60;
|
||
|
||
// 10. Set hour to hour + floor(minute / 60).
|
||
hour += minute / 60;
|
||
|
||
// 11. Set minute to minute modulo 60.
|
||
minute %= 60;
|
||
|
||
// 12. Let days be floor(hour / 24).
|
||
u8 days = hour / 24;
|
||
|
||
// 13. Set hour to hour modulo 24.
|
||
hour %= 24;
|
||
|
||
// 14. Return the Record { [[Days]]: days, [[Hour]]: hour, [[Minute]]: minute, [[Second]]: second, [[Millisecond]]: millisecond, [[Microsecond]]: microsecond, [[Nanosecond]]: nanosecond }.
|
||
return DaysAndTime {
|
||
.days = static_cast<i32>(days),
|
||
.hour = static_cast<u8>(hour),
|
||
.minute = static_cast<u8>(minute),
|
||
.second = static_cast<u8>(second),
|
||
.millisecond = static_cast<u16>(millisecond),
|
||
.microsecond = static_cast<u16>(microsecond),
|
||
.nanosecond = static_cast<u16>(nanosecond),
|
||
};
|
||
}
|
||
|
||
// 4.5.7 ConstrainTime ( hour, minute, second, millisecond, microsecond, nanosecond ), https://tc39.es/proposal-temporal/#sec-temporal-constraintime
|
||
TemporalTime constrain_time(double hour, double minute, double second, double millisecond, double microsecond, double nanosecond)
|
||
{
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond, and nanosecond are integers.
|
||
|
||
// 2. Set hour to ! ConstrainToRange(hour, 0, 23).
|
||
hour = constrain_to_range(hour, 0, 23);
|
||
|
||
// 3. Set minute to ! ConstrainToRange(minute, 0, 59).
|
||
minute = constrain_to_range(minute, 0, 59);
|
||
|
||
// 4. Set second to ! ConstrainToRange(second, 0, 59).
|
||
second = constrain_to_range(second, 0, 59);
|
||
|
||
// 5. Set millisecond to ! ConstrainToRange(millisecond, 0, 999).
|
||
millisecond = constrain_to_range(millisecond, 0, 999);
|
||
|
||
// 6. Set microsecond to ! ConstrainToRange(microsecond, 0, 999).
|
||
microsecond = constrain_to_range(microsecond, 0, 999);
|
||
|
||
// 7. Set nanosecond to ! ConstrainToRange(nanosecond, 0, 999).
|
||
nanosecond = constrain_to_range(nanosecond, 0, 999);
|
||
|
||
// 8. Return the Record { [[Hour]]: hour, [[Minute]]: minute, [[Second]]: second, [[Millisecond]]: millisecond, [[Microsecond]]: microsecond, [[Nanosecond]]: nanosecond }.
|
||
return TemporalTime { .hour = static_cast<u8>(hour), .minute = static_cast<u8>(minute), .second = static_cast<u8>(second), .millisecond = static_cast<u16>(millisecond), .microsecond = static_cast<u16>(microsecond), .nanosecond = static_cast<u16>(nanosecond) };
|
||
}
|
||
|
||
// 4.5.8 CreateTemporalTime ( hour, minute, second, millisecond, microsecond, nanosecond [ , newTarget ] ), https://tc39.es/proposal-temporal/#sec-temporal-createtemporaltime
|
||
ThrowCompletionOr<PlainTime*> create_temporal_time(GlobalObject& global_object, u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, FunctionObject const* new_target)
|
||
{
|
||
auto& vm = global_object.vm();
|
||
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond and nanosecond are integers.
|
||
|
||
// 2. If ! IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond) is false, throw a RangeError exception.
|
||
if (!is_valid_time(hour, minute, second, millisecond, microsecond, nanosecond))
|
||
return vm.throw_completion<RangeError>(global_object, ErrorType::TemporalInvalidPlainTime);
|
||
|
||
// 3. If newTarget is not present, set it to %Temporal.PlainTime%.
|
||
if (!new_target)
|
||
new_target = global_object.temporal_plain_time_constructor();
|
||
|
||
// 4. Let object be ? OrdinaryCreateFromConstructor(newTarget, "%Temporal.PlainTime.prototype%", « [[InitializedTemporalTime]], [[ISOHour]], [[ISOMinute]], [[ISOSecond]], [[ISOMillisecond]], [[ISOMicrosecond]], [[ISONanosecond]], [[Calendar]] »).
|
||
// 5. Set object.[[ISOHour]] to hour.
|
||
// 6. Set object.[[ISOMinute]] to minute.
|
||
// 7. Set object.[[ISOSecond]] to second.
|
||
// 8. Set object.[[ISOMillisecond]] to millisecond.
|
||
// 9. Set object.[[ISOMicrosecond]] to microsecond.
|
||
// 10. Set object.[[ISONanosecond]] to nanosecond.
|
||
// 11. Set object.[[Calendar]] to ! GetISO8601Calendar().
|
||
auto* object = TRY(ordinary_create_from_constructor<PlainTime>(global_object, *new_target, &GlobalObject::temporal_plain_time_prototype, hour, minute, second, millisecond, microsecond, nanosecond, *get_iso8601_calendar(global_object)));
|
||
|
||
// 12. Return object.
|
||
return object;
|
||
}
|
||
|
||
// 4.5.9 ToTemporalTimeRecord ( temporalTimeLike ), https://tc39.es/proposal-temporal/#sec-temporal-totemporaltimerecord
|
||
ThrowCompletionOr<UnregulatedTemporalTime> to_temporal_time_record(GlobalObject& global_object, Object const& temporal_time_like)
|
||
{
|
||
auto& vm = global_object.vm();
|
||
|
||
// 1. Assert: Type(temporalTimeLike) is Object.
|
||
|
||
// 2. Let result be the Record { [[Hour]]: undefined, [[Minute]]: undefined, [[Second]]: undefined, [[Millisecond]]: undefined, [[Microsecond]]: undefined, [[Nanosecond]]: undefined }.
|
||
auto result = UnregulatedTemporalTime {};
|
||
|
||
// 3. For each row of Table 3, except the header row, in table order, do
|
||
for (auto& [internal_slot, property] : temporal_time_like_properties<UnregulatedTemporalTime, double>(vm)) {
|
||
// a. Let property be the Property value of the current row.
|
||
|
||
// b. Let value be ? Get(temporalTimeLike, property).
|
||
auto value = temporal_time_like.get(property);
|
||
if (auto* exception = vm.exception())
|
||
return throw_completion(exception->value());
|
||
|
||
// c. If value is undefined, then
|
||
if (value.is_undefined()) {
|
||
// i. Throw a TypeError exception.
|
||
return vm.throw_completion<TypeError>(global_object, ErrorType::TemporalMissingRequiredProperty, property);
|
||
}
|
||
|
||
// d. Set value to ? ToIntegerThrowOnInfinity(value).
|
||
auto value_number = TRY(to_integer_throw_on_infinity(global_object, value, ErrorType::TemporalPropertyMustBeFinite));
|
||
|
||
// e. Set result's internal slot whose name is the Internal Slot value of the current row to value.
|
||
result.*internal_slot = value_number;
|
||
}
|
||
|
||
// 4. Return result.
|
||
return result;
|
||
}
|
||
|
||
// 4.5.10 TemporalTimeToString ( hour, minute, second, millisecond, microsecond, nanosecond, precision ), https://tc39.es/proposal-temporal/#sec-temporal-temporaltimetostring
|
||
String temporal_time_to_string(u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, Variant<StringView, u8> const& precision)
|
||
{
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond and nanosecond are integers.
|
||
|
||
// 2. Let hour be hour formatted as a two-digit decimal number, padded to the left with a zero if necessary.
|
||
// 3. Let minute be minute formatted as a two-digit decimal number, padded to the left with a zero if necessary.
|
||
|
||
// 4. Let seconds be ! FormatSecondsStringPart(second, millisecond, microsecond, nanosecond, precision).
|
||
auto seconds = format_seconds_string_part(second, millisecond, microsecond, nanosecond, precision);
|
||
|
||
// 5. Return the string-concatenation of hour, the code unit 0x003A (COLON), minute, and seconds.
|
||
return String::formatted("{:02}:{:02}{}", hour, minute, seconds);
|
||
}
|
||
|
||
// 4.5.11 CompareTemporalTime ( h1, min1, s1, ms1, mus1, ns1, h2, min2, s2, ms2, mus2, ns2 ), https://tc39.es/proposal-temporal/#sec-temporal-comparetemporaltime
|
||
i8 compare_temporal_time(u8 hour1, u8 minute1, u8 second1, u16 millisecond1, u16 microsecond1, u16 nanosecond1, u8 hour2, u8 minute2, u8 second2, u16 millisecond2, u16 microsecond2, u16 nanosecond2)
|
||
{
|
||
// 1. Assert: h1, min1, s1, ms1, mus1, ns1, h2, min2, s2, ms2, mus2, and ns2 are integers.
|
||
|
||
// 2. If h1 > h2, return 1.
|
||
if (hour1 > hour2)
|
||
return 1;
|
||
|
||
// 3. If h1 < h2, return -1.
|
||
if (hour1 < hour2)
|
||
return -1;
|
||
|
||
// 4. If min1 > min2, return 1.
|
||
if (minute1 > minute2)
|
||
return 1;
|
||
|
||
// 5. If min1 < min2, return -1.
|
||
if (minute1 < minute2)
|
||
return -1;
|
||
|
||
// 6. If s1 > s2, return 1.
|
||
if (second1 > second2)
|
||
return 1;
|
||
|
||
// 7. If s1 < s2, return -1.
|
||
if (second1 < second2)
|
||
return -1;
|
||
|
||
// 8. If ms1 > ms2, return 1.
|
||
if (millisecond1 > millisecond2)
|
||
return 1;
|
||
|
||
// 9. If ms1 < ms2, return -1.
|
||
if (millisecond1 < millisecond2)
|
||
return -1;
|
||
|
||
// 10. If mus1 > mus2, return 1.
|
||
if (microsecond1 > microsecond2)
|
||
return 1;
|
||
|
||
// 11. If mus1 < mus2, return -1.
|
||
if (microsecond1 < microsecond2)
|
||
return -1;
|
||
|
||
// 12. If ns1 > ns2, return 1.
|
||
if (nanosecond1 > nanosecond2)
|
||
return 1;
|
||
|
||
// 13. If ns1 < ns2, return -1.
|
||
if (nanosecond1 < nanosecond2)
|
||
return -1;
|
||
|
||
// 14. Return 0.
|
||
return 0;
|
||
}
|
||
|
||
// 4.5.13 RoundTime ( hour, minute, second, millisecond, microsecond, nanosecond, increment, unit, roundingMode [ , dayLengthNs ] ), https://tc39.es/proposal-temporal/#sec-temporal-roundtime
|
||
DaysAndTime round_time(GlobalObject& global_object, u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, u64 increment, StringView unit, StringView rounding_mode, Optional<double> day_length_ns)
|
||
{
|
||
// 1. Assert: hour, minute, second, millisecond, microsecond, nanosecond, and increment are integers.
|
||
|
||
// 2. Let fractionalSecond be nanosecond × 10−9 + microsecond × 10−6 + millisecond × 10−3 + second.
|
||
double fractional_second = nanosecond * 0.000000001 + microsecond * 0.000001 + millisecond * 0.001 + second;
|
||
double quantity;
|
||
|
||
// 3. If unit is "day", then
|
||
if (unit == "day"sv) {
|
||
// a. If dayLengthNs is not present, set it to 8.64 × 10^13.
|
||
if (!day_length_ns.has_value())
|
||
day_length_ns = 86400000000000;
|
||
|
||
// b. Let quantity be (((((hour × 60 + minute) × 60 + second) × 1000 + millisecond) × 1000 + microsecond) × 1000 + nanosecond) / dayLengthNs.
|
||
quantity = (((((hour * 60 + minute) * 60 + second) * 1000 + millisecond) * 1000 + microsecond) * 1000 + nanosecond) / *day_length_ns;
|
||
}
|
||
// 4. Else if unit is "hour", then
|
||
else if (unit == "hour"sv) {
|
||
// a. Let quantity be (fractionalSecond / 60 + minute) / 60 + hour.
|
||
quantity = (fractional_second / 60 + minute) / 60 + hour;
|
||
}
|
||
// 5. Else if unit is "minute", then
|
||
else if (unit == "minute"sv) {
|
||
// a. Let quantity be fractionalSecond / 60 + minute.
|
||
quantity = fractional_second / 60 + minute;
|
||
}
|
||
// 6. Else if unit is "second", then
|
||
else if (unit == "second"sv) {
|
||
// a. Let quantity be fractionalSecond.
|
||
quantity = fractional_second;
|
||
}
|
||
// 7. Else if unit is "millisecond", then
|
||
else if (unit == "millisecond"sv) {
|
||
// a. Let quantity be nanosecond × 10−6 + microsecond × 10−3 + millisecond.
|
||
quantity = nanosecond * 0.000001 + 0.001 * microsecond + millisecond;
|
||
}
|
||
// 8. Else if unit is "microsecond", then
|
||
else if (unit == "microsecond"sv) {
|
||
// a. Let quantity be nanosecond × 10−3 + microsecond.
|
||
quantity = nanosecond * 0.001 + microsecond;
|
||
}
|
||
// 9. Else,
|
||
else {
|
||
// a. Assert: unit is "nanosecond".
|
||
VERIFY(unit == "nanosecond"sv);
|
||
|
||
// b. Let quantity be nanosecond.
|
||
quantity = nanosecond;
|
||
}
|
||
|
||
// FIXME: This doesn't seem right...
|
||
auto* quantity_bigint = js_bigint(global_object.vm(), Crypto::SignedBigInteger::create_from((u64)quantity));
|
||
|
||
// 10. Let result be ! RoundNumberToIncrement(quantity, increment, roundingMode).
|
||
auto* result = round_number_to_increment(global_object, *quantity_bigint, increment, rounding_mode);
|
||
|
||
auto result_i64 = (i64)result->big_integer().to_double();
|
||
|
||
// If unit is "day", then
|
||
if (unit == "day"sv) {
|
||
// a. Return the Record { [[Days]]: result, [[Hour]]: 0, [[Minute]]: 0, [[Second]]: 0, [[Millisecond]]: 0, [[Microsecond]]: 0, [[Nanosecond]]: 0 }.
|
||
return DaysAndTime { .days = (i32)result_i64, .hour = 0, .minute = 0, .second = 0, .millisecond = 0, .microsecond = 0, .nanosecond = 0 };
|
||
}
|
||
|
||
// 12. If unit is "hour", then
|
||
if (unit == "hour"sv) {
|
||
// a. Return ! BalanceTime(result, 0, 0, 0, 0, 0).
|
||
return balance_time(result_i64, 0, 0, 0, 0, 0);
|
||
}
|
||
|
||
// 13. If unit is "minute", then
|
||
if (unit == "minute"sv) {
|
||
// a. Return ! BalanceTime(hour, result, 0, 0, 0, 0).
|
||
return balance_time(hour, result_i64, 0, 0, 0, 0);
|
||
}
|
||
|
||
// 14. If unit is "second", then
|
||
if (unit == "second"sv) {
|
||
// a. Return ! BalanceTime(hour, minute, result, 0, 0, 0).
|
||
return balance_time(hour, minute, result_i64, 0, 0, 0);
|
||
}
|
||
|
||
// 15. If unit is "millisecond", then
|
||
if (unit == "millisecond"sv) {
|
||
// a. Return ! BalanceTime(hour, minute, second, result, 0, 0).
|
||
return balance_time(hour, minute, second, result_i64, 0, 0);
|
||
}
|
||
|
||
// 16. If unit is "microsecond", then
|
||
if (unit == "microsecond"sv) {
|
||
// a. Return ! BalanceTime(hour, minute, second, millisecond, result, 0).
|
||
return balance_time(hour, minute, second, millisecond, result_i64, 0);
|
||
}
|
||
|
||
// 17. Assert: unit is "nanosecond".
|
||
VERIFY(unit == "nanosecond"sv);
|
||
|
||
// 18. Return ! BalanceTime(hour, minute, second, millisecond, microsecond, result).
|
||
return balance_time(hour, minute, second, millisecond, microsecond, result_i64);
|
||
}
|
||
|
||
}
|