ZonedDateTime.cpp 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502
  1. /*
  2. * Copyright (c) 2021, Linus Groh <linusg@serenityos.org>
  3. * Copyright (c) 2021, Luke Wilde <lukew@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <LibJS/Runtime/AbstractOperations.h>
  8. #include <LibJS/Runtime/GlobalObject.h>
  9. #include <LibJS/Runtime/Temporal/Calendar.h>
  10. #include <LibJS/Runtime/Temporal/Duration.h>
  11. #include <LibJS/Runtime/Temporal/Instant.h>
  12. #include <LibJS/Runtime/Temporal/PlainDate.h>
  13. #include <LibJS/Runtime/Temporal/PlainDateTime.h>
  14. #include <LibJS/Runtime/Temporal/TimeZone.h>
  15. #include <LibJS/Runtime/Temporal/ZonedDateTime.h>
  16. #include <LibJS/Runtime/Temporal/ZonedDateTimeConstructor.h>
  17. namespace JS::Temporal {
  18. // 6 Temporal.ZonedDateTime Objects, https://tc39.es/proposal-temporal/#sec-temporal-zoneddatetime-objects
  19. ZonedDateTime::ZonedDateTime(BigInt const& nanoseconds, Object& time_zone, Object& calendar, Object& prototype)
  20. : Object(prototype)
  21. , m_nanoseconds(nanoseconds)
  22. , m_time_zone(time_zone)
  23. , m_calendar(calendar)
  24. {
  25. }
  26. void ZonedDateTime::visit_edges(Cell::Visitor& visitor)
  27. {
  28. Base::visit_edges(visitor);
  29. visitor.visit(&m_nanoseconds);
  30. visitor.visit(&m_time_zone);
  31. visitor.visit(&m_calendar);
  32. }
  33. // 6.5.1 InterpretISODateTimeOffset ( year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, offsetBehaviour, offsetNanoseconds, timeZone, disambiguation, offsetOption, matchBehaviour ), https://tc39.es/proposal-temporal/#sec-temporal-interpretisodatetimeoffset
  34. ThrowCompletionOr<BigInt const*> interpret_iso_date_time_offset(GlobalObject& global_object, i32 year, u8 month, u8 day, u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, OffsetBehavior offset_behavior, double offset_nanoseconds, Value time_zone, StringView disambiguation, StringView offset_option, MatchBehavior match_behavior)
  35. {
  36. auto& vm = global_object.vm();
  37. // 1. Assert: offsetNanoseconds is an integer.
  38. VERIFY(trunc(offset_nanoseconds) == offset_nanoseconds);
  39. // 2. Let calendar be ! GetISO8601Calendar().
  40. auto* calendar = get_iso8601_calendar(global_object);
  41. // 3. Let dateTime be ? CreateTemporalDateTime(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, calendar).
  42. auto* date_time = TRY(create_temporal_date_time(global_object, year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, *calendar));
  43. // 4. If offsetBehaviour is wall, or offsetOption is "ignore", then
  44. if (offset_behavior == OffsetBehavior::Wall || offset_option == "ignore"sv) {
  45. // a. Let instant be ? BuiltinTimeZoneGetInstantFor(timeZone, dateTime, disambiguation).
  46. auto* instant = TRY(builtin_time_zone_get_instant_for(global_object, time_zone, *date_time, disambiguation));
  47. // b. Return instant.[[Nanoseconds]].
  48. return &instant->nanoseconds();
  49. }
  50. // 5. If offsetBehaviour is exact, or offsetOption is "use", then
  51. if (offset_behavior == OffsetBehavior::Exact || offset_option == "use"sv) {
  52. // a. Let epochNanoseconds be ! GetEpochFromISOParts(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond).
  53. auto* epoch_nanoseconds = get_epoch_from_iso_parts(global_object, year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
  54. // b. Return epochNanoseconds − offsetNanoseconds.
  55. auto offset_nanoseconds_bigint = Crypto::SignedBigInteger::create_from((i64)offset_nanoseconds);
  56. return js_bigint(vm, epoch_nanoseconds->big_integer().minus(offset_nanoseconds_bigint));
  57. }
  58. // 6. Assert: offsetBehaviour is option.
  59. VERIFY(offset_behavior == OffsetBehavior::Option);
  60. // 7. Assert: offsetOption is "prefer" or "reject".
  61. VERIFY(offset_option.is_one_of("prefer"sv, "reject"sv));
  62. // 8. Let possibleInstants be ? GetPossibleInstantsFor(timeZone, dateTime).
  63. auto possible_instants = TRY(get_possible_instants_for(global_object, time_zone, *date_time));
  64. // 9. For each element candidate of possibleInstants, do
  65. for (auto& candidate_value : possible_instants) {
  66. // TODO: As per the comment in disambiguate_possible_instants, having a MarkedValueList<T> would allow us to remove this cast.
  67. auto& candidate = static_cast<Instant&>(candidate_value.as_object());
  68. // a. Let candidateNanoseconds be ? GetOffsetNanosecondsFor(timeZone, candidate).
  69. auto candidate_nanoseconds = TRY(get_offset_nanoseconds_for(global_object, time_zone, candidate));
  70. // b. If candidateNanoseconds = offsetNanoseconds, then
  71. if (candidate_nanoseconds == offset_nanoseconds) {
  72. // i. Return candidate.[[Nanoseconds]].
  73. return &candidate.nanoseconds();
  74. }
  75. // c. If matchBehaviour is match minutes, then
  76. if (match_behavior == MatchBehavior::MatchMinutes) {
  77. // i. Let roundedCandidateNanoseconds be ! RoundNumberToIncrement(candidateNanoseconds, 60 × 10^9, "halfExpand").
  78. auto rounded_candidate_nanoseconds = round_number_to_increment(candidate_nanoseconds, 60000000000, "halfExpand"sv);
  79. // ii. If roundedCandidateNanoseconds = offsetNanoseconds, then
  80. if (rounded_candidate_nanoseconds == offset_nanoseconds) {
  81. // 1. Return candidate.[[Nanoseconds]].
  82. return &candidate.nanoseconds();
  83. }
  84. }
  85. }
  86. // 10. If offsetOption is "reject", throw a RangeError exception.
  87. if (offset_option == "reject"sv)
  88. return vm.throw_completion<RangeError>(global_object, ErrorType::TemporalInvalidZonedDateTimeOffset);
  89. // 11. Let instant be ? DisambiguatePossibleInstants(possibleInstants, timeZone, dateTime, disambiguation).
  90. auto* instant = TRY(disambiguate_possible_instants(global_object, possible_instants, time_zone, *date_time, disambiguation));
  91. // 12. Return instant.[[Nanoseconds]].
  92. return &instant->nanoseconds();
  93. }
  94. // 6.5.2 ToTemporalZonedDateTime ( item [ , options ] ), https://tc39.es/proposal-temporal/#sec-temporal-totemporalzoneddatetime
  95. ThrowCompletionOr<ZonedDateTime*> to_temporal_zoned_date_time(GlobalObject& global_object, Value item, Object* options)
  96. {
  97. auto& vm = global_object.vm();
  98. // 1. If options is not present, set options to ! OrdinaryObjectCreate(null).
  99. if (!options)
  100. options = Object::create(global_object, nullptr);
  101. // 2. Let offsetBehaviour be option.
  102. auto offset_behavior = OffsetBehavior::Option;
  103. // 3. Let matchBehaviour be match exactly.
  104. auto match_behavior = MatchBehavior::MatchExactly;
  105. Object* calendar = nullptr;
  106. Object* time_zone = nullptr;
  107. Optional<String> offset_string;
  108. ISODateTime result;
  109. // 4. If Type(item) is Object, then
  110. if (item.is_object()) {
  111. auto& item_object = item.as_object();
  112. // a. If item has an [[InitializedTemporalZonedDateTime]] internal slot, then
  113. if (is<ZonedDateTime>(item_object)) {
  114. // i. Return item.
  115. return &static_cast<ZonedDateTime&>(item_object);
  116. }
  117. // b. Let calendar be ? GetTemporalCalendarWithISODefault(item).
  118. calendar = TRY(get_temporal_calendar_with_iso_default(global_object, item_object));
  119. // c. Let fieldNames be ? CalendarFields(calendar, « "day", "hour", "microsecond", "millisecond", "minute", "month", "monthCode", "nanosecond", "second", "year" »).
  120. auto field_names = TRY(calendar_fields(global_object, *calendar, { "day"sv, "hour"sv, "microsecond"sv, "millisecond"sv, "minute"sv, "month"sv, "monthCode"sv, "nanosecond"sv, "second"sv, "year"sv }));
  121. // d. Append "timeZone" to fieldNames.
  122. field_names.append("timeZone");
  123. // e. Append "offset" to fieldNames.
  124. field_names.append("offset");
  125. // f. Let fields be ? PrepareTemporalFields(item, fieldNames, « "timeZone" »).
  126. auto* fields = TRY(prepare_temporal_fields(global_object, item_object, field_names, { "timeZone"sv }));
  127. // g. Let timeZone be ? Get(fields, "timeZone").
  128. auto time_zone_value = TRY(fields->get(vm.names.timeZone));
  129. // h. Set timeZone to ? ToTemporalTimeZone(timeZone).
  130. time_zone = TRY(to_temporal_time_zone(global_object, time_zone_value));
  131. // i. Let offsetString be ? Get(fields, "offset").
  132. auto offset_string_value = TRY(fields->get(vm.names.offset));
  133. // j. If offsetString is undefined, then
  134. if (offset_string_value.is_undefined()) {
  135. // i. Set offsetBehaviour to wall.
  136. offset_behavior = OffsetBehavior::Wall;
  137. }
  138. // k. Else,
  139. else {
  140. // i. Set offsetString to ? ToString(offsetString).
  141. offset_string = TRY(offset_string_value.to_string(global_object));
  142. }
  143. // l. Let result be ? InterpretTemporalDateTimeFields(calendar, fields, options).
  144. result = TRY(interpret_temporal_date_time_fields(global_object, *calendar, *fields, *options));
  145. }
  146. // 5. Else,
  147. else {
  148. // a. Perform ? ToTemporalOverflow(options).
  149. (void)TRY(to_temporal_overflow(global_object, *options));
  150. // b. Let string be ? ToString(item).
  151. auto string = TRY(item.to_string(global_object));
  152. // c. Let result be ? ParseTemporalZonedDateTimeString(string).
  153. auto parsed_result = TRY(parse_temporal_zoned_date_time_string(global_object, string));
  154. // NOTE: The ISODateTime struct inside parsed_result will be moved into `result` at the end of this path to avoid mismatching names.
  155. // Thus, all remaining references to `result` in this path actually refers to `parsed_result`.
  156. // d. Assert: result.[[TimeZoneName]] is not undefined.
  157. VERIFY(parsed_result.time_zone.name.has_value());
  158. // e. Let offsetString be result.[[TimeZoneOffsetString]].
  159. offset_string = move(parsed_result.time_zone.offset);
  160. // f. If result.[[TimeZoneZ]] is true, then
  161. if (parsed_result.time_zone.z) {
  162. // i. Set offsetBehaviour to exact.
  163. offset_behavior = OffsetBehavior::Exact;
  164. }
  165. // g. Else if offsetString is undefined, then
  166. else if (!offset_string.has_value()) {
  167. // i. Set offsetBehaviour to wall.
  168. offset_behavior = OffsetBehavior::Wall;
  169. }
  170. // h. Let timeZone be ? CreateTemporalTimeZone(result.[[TimeZoneName]]).
  171. time_zone = TRY(create_temporal_time_zone(global_object, *parsed_result.time_zone.name));
  172. // i. Let calendar be ? ToTemporalCalendarWithISODefault(result.[[Calendar]]).
  173. auto temporal_calendar_like = parsed_result.date_time.calendar.has_value()
  174. ? js_string(vm, parsed_result.date_time.calendar.value())
  175. : js_undefined();
  176. calendar = TRY(to_temporal_calendar_with_iso_default(global_object, temporal_calendar_like));
  177. // j. Set matchBehaviour to match minutes.
  178. match_behavior = MatchBehavior::MatchMinutes;
  179. // See NOTE above about why this is done.
  180. result = move(parsed_result.date_time);
  181. }
  182. // 6. Let offsetNanoseconds be 0.
  183. double offset_nanoseconds = 0;
  184. // 7. If offsetBehaviour is option, then
  185. if (offset_behavior == OffsetBehavior::Option) {
  186. // a. Set offsetNanoseconds to ? ParseTimeZoneOffsetString(offsetString).
  187. offset_nanoseconds = TRY(parse_time_zone_offset_string(global_object, *offset_string));
  188. }
  189. // 8. Let disambiguation be ? ToTemporalDisambiguation(options).
  190. auto disambiguation = TRY(to_temporal_disambiguation(global_object, *options));
  191. // 9. Let offsetOption be ? ToTemporalOffset(options, "reject").
  192. auto offset_option = TRY(to_temporal_offset(global_object, *options, "reject"));
  193. // 10. Let epochNanoseconds be ? InterpretISODateTimeOffset(result.[[Year]], result.[[Month]], result.[[Day]], result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]], offsetBehaviour, offsetNanoseconds, timeZone, disambiguation, offsetOption, matchBehaviour).
  194. auto* epoch_nanoseconds = TRY(interpret_iso_date_time_offset(global_object, result.year, result.month, result.day, result.hour, result.minute, result.second, result.millisecond, result.microsecond, result.nanosecond, offset_behavior, offset_nanoseconds, time_zone, disambiguation, offset_option, match_behavior));
  195. // 11. Return ! CreateTemporalZonedDateTime(epochNanoseconds, timeZone, calendar).
  196. return MUST(create_temporal_zoned_date_time(global_object, *epoch_nanoseconds, *time_zone, *calendar));
  197. }
  198. // 6.5.3 CreateTemporalZonedDateTime ( epochNanoseconds, timeZone, calendar [ , newTarget ] ), https://tc39.es/proposal-temporal/#sec-temporal-createtemporalzoneddatetime
  199. ThrowCompletionOr<ZonedDateTime*> create_temporal_zoned_date_time(GlobalObject& global_object, BigInt const& epoch_nanoseconds, Object& time_zone, Object& calendar, FunctionObject const* new_target)
  200. {
  201. // 1. Assert: Type(epochNanoseconds) is BigInt.
  202. // 3. Assert: Type(timeZone) is Object.
  203. // 4. Assert: Type(calendar) is Object.
  204. // 2. Assert: ! IsValidEpochNanoseconds(epochNanoseconds) is true.
  205. VERIFY(is_valid_epoch_nanoseconds(epoch_nanoseconds));
  206. // 5. If newTarget is not present, set it to %Temporal.ZonedDateTime%.
  207. if (!new_target)
  208. new_target = global_object.temporal_zoned_date_time_constructor();
  209. // 6. Let object be ? OrdinaryCreateFromConstructor(newTarget, "%Temporal.ZonedDateTime.prototype%", « [[InitializedTemporalZonedDateTime]], [[Nanoseconds]], [[TimeZone]], [[Calendar]] »).
  210. // 7. Set object.[[Nanoseconds]] to epochNanoseconds.
  211. // 8. Set object.[[TimeZone]] to timeZone.
  212. // 9. Set object.[[Calendar]] to calendar.
  213. auto* object = TRY(ordinary_create_from_constructor<ZonedDateTime>(global_object, *new_target, &GlobalObject::temporal_time_zone_prototype, epoch_nanoseconds, time_zone, calendar));
  214. // 10. Return object.
  215. return object;
  216. }
  217. // 6.5.4 TemporalZonedDateTimeToString ( zonedDateTime, precision, showCalendar, showTimeZone, showOffset [ , increment, unit, roundingMode ] ), https://tc39.es/proposal-temporal/#sec-temporal-temporalzoneddatetimetostring
  218. ThrowCompletionOr<String> temporal_zoned_date_time_to_string(GlobalObject& global_object, ZonedDateTime& zoned_date_time, Variant<StringView, u8> const& precision, StringView show_calendar, StringView show_time_zone, StringView show_offset, Optional<u64> increment, Optional<StringView> unit, Optional<StringView> rounding_mode)
  219. {
  220. // 1. Assert: Type(zonedDateTime) is Object and zonedDateTime has an [[InitializedTemporalZonedDateTime]] internal slot.
  221. // 2. If increment is not present, set it to 1.
  222. if (!increment.has_value())
  223. increment = 1;
  224. // 3. If unit is not present, set it to "nanosecond".
  225. if (!unit.has_value())
  226. unit = "nanosecond"sv;
  227. // 4. If roundingMode is not present, set it to "trunc".
  228. if (!rounding_mode.has_value())
  229. rounding_mode = "trunc"sv;
  230. // 5. Let ns be ! RoundTemporalInstant(zonedDateTime.[[Nanoseconds]], increment, unit, roundingMode).
  231. auto* ns = round_temporal_instant(global_object, zoned_date_time.nanoseconds(), *increment, *unit, *rounding_mode);
  232. // 6. Let timeZone be zonedDateTime.[[TimeZone]].
  233. auto& time_zone = zoned_date_time.time_zone();
  234. // 7. Let instant be ! CreateTemporalInstant(ns).
  235. auto* instant = MUST(create_temporal_instant(global_object, *ns));
  236. // 8. Let isoCalendar be ! GetISO8601Calendar().
  237. auto* iso_calendar = get_iso8601_calendar(global_object);
  238. // 9. Let temporalDateTime be ? BuiltinTimeZoneGetPlainDateTimeFor(timeZone, instant, isoCalendar).
  239. auto* temporal_date_time = TRY(builtin_time_zone_get_plain_date_time_for(global_object, &time_zone, *instant, *iso_calendar));
  240. // 10. Let dateTimeString be ? TemporalDateTimeToString(temporalDateTime.[[ISOYear]], temporalDateTime.[[ISOMonth]], temporalDateTime.[[ISODay]], temporalDateTime.[[ISOHour]], temporalDateTime.[[ISOMinute]], temporalDateTime.[[ISOSecond]], temporalDateTime.[[ISOMillisecond]], temporalDateTime.[[ISOMicrosecond]], temporalDateTime.[[ISONanosecond]], isoCalendar, precision, "never").
  241. auto date_time_string = TRY(temporal_date_time_to_string(global_object, temporal_date_time->iso_year(), temporal_date_time->iso_month(), temporal_date_time->iso_day(), temporal_date_time->iso_hour(), temporal_date_time->iso_minute(), temporal_date_time->iso_second(), temporal_date_time->iso_millisecond(), temporal_date_time->iso_microsecond(), temporal_date_time->iso_nanosecond(), iso_calendar, precision, "never"sv));
  242. String offset_string;
  243. // 11. If showOffset is "never", then
  244. if (show_offset == "never"sv) {
  245. // a. Let offsetString be the empty String.
  246. offset_string = String::empty();
  247. }
  248. // Else,
  249. else {
  250. // a. Let offsetNs be ? GetOffsetNanosecondsFor(timeZone, instant).
  251. auto offset_ns = TRY(get_offset_nanoseconds_for(global_object, &time_zone, *instant));
  252. // b. Let offsetString be ! FormatISOTimeZoneOffsetString(offsetNs).
  253. offset_string = format_iso_time_zone_offset_string(offset_ns);
  254. }
  255. String time_zone_string;
  256. // 13. If showTimeZone is "never", then
  257. if (show_time_zone == "never"sv) {
  258. // a. Let timeZoneString be the empty String.
  259. time_zone_string = String::empty();
  260. }
  261. // 14. Else,
  262. else {
  263. // a. Let timeZoneID be ? ToString(timeZone).
  264. auto time_zone_id = TRY(Value(&time_zone).to_string(global_object));
  265. // b. Let timeZoneString be the string-concatenation of the code unit 0x005B (LEFT SQUARE BRACKET), timeZoneID, and the code unit 0x005D (RIGHT SQUARE BRACKET).
  266. time_zone_string = String::formatted("[{}]", time_zone_id);
  267. }
  268. // 15. Let calendarID be ? ToString(zonedDateTime.[[Calendar]]).
  269. auto calendar_id = TRY(Value(&zoned_date_time.calendar()).to_string(global_object));
  270. // 16. Let calendarString be ! FormatCalendarAnnotation(calendarID, showCalendar).
  271. auto calendar_string = format_calendar_annotation(calendar_id, show_calendar);
  272. // 17. Return the string-concatenation of dateTimeString, offsetString, timeZoneString, and calendarString.
  273. return String::formatted("{}{}{}{}", date_time_string, offset_string, time_zone_string, calendar_string);
  274. }
  275. // 6.5.5 AddZonedDateTime ( epochNanoseconds, timeZone, calendar, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds [ , options ] ), https://tc39.es/proposal-temporal/#sec-temporal-addzoneddatetime
  276. ThrowCompletionOr<BigInt*> add_zoned_date_time(GlobalObject& global_object, BigInt const& epoch_nanoseconds, Value time_zone, Object& calendar, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, Object* options)
  277. {
  278. // 1. If options is not present, set options to ! OrdinaryObjectCreate(null).
  279. if (!options)
  280. options = Object::create(global_object, nullptr);
  281. // 2. If all of years, months, weeks, and days are 0, then
  282. if (years == 0 && months == 0 && weeks == 0 && days == 0) {
  283. // a. Return ! AddInstant(epochNanoseconds, hours, minutes, seconds, milliseconds, microseconds, nanoseconds).
  284. return MUST(add_instant(global_object, epoch_nanoseconds, hours, minutes, seconds, milliseconds, microseconds, nanoseconds));
  285. }
  286. // 3. Let instant be ! CreateTemporalInstant(epochNanoseconds).
  287. auto* instant = MUST(create_temporal_instant(global_object, epoch_nanoseconds));
  288. // 4. Let temporalDateTime be ? BuiltinTimeZoneGetPlainDateTimeFor(timeZone, instant, calendar).
  289. auto* temporal_date_time = TRY(builtin_time_zone_get_plain_date_time_for(global_object, time_zone, *instant, calendar));
  290. // 5. Let datePart be ? CreateTemporalDate(temporalDateTime.[[ISOYear]], temporalDateTime.[[ISOMonth]], temporalDateTime.[[ISODay]], calendar).
  291. auto* date_part = TRY(create_temporal_date(global_object, temporal_date_time->iso_year(), temporal_date_time->iso_month(), temporal_date_time->iso_day(), calendar));
  292. // 6. Let dateDuration be ? CreateTemporalDuration(years, months, weeks, days, 0, 0, 0, 0, 0, 0).
  293. auto* date_duration = TRY(create_temporal_duration(global_object, years, months, weeks, days, 0, 0, 0, 0, 0, 0));
  294. // 7. Let addedDate be ? CalendarDateAdd(calendar, datePart, dateDuration, options).
  295. auto* added_date = TRY(calendar_date_add(global_object, calendar, date_part, *date_duration, options));
  296. // 8. Let intermediateDateTime be ? CreateTemporalDateTime(addedDate.[[ISOYear]], addedDate.[[ISOMonth]], addedDate.[[ISODay]], temporalDateTime.[[ISOHour]], temporalDateTime.[[ISOMinute]], temporalDateTime.[[ISOSecond]], temporalDateTime.[[ISOMillisecond]], temporalDateTime.[[ISOMicrosecond]], temporalDateTime.[[ISONanosecond]], calendar).
  297. auto* intermediate_date_time = TRY(create_temporal_date_time(global_object, added_date->iso_year(), added_date->iso_month(), added_date->iso_day(), temporal_date_time->iso_hour(), temporal_date_time->iso_minute(), temporal_date_time->iso_second(), temporal_date_time->iso_millisecond(), temporal_date_time->iso_microsecond(), temporal_date_time->iso_nanosecond(), calendar));
  298. // 9. Let intermediateInstant be ? BuiltinTimeZoneGetInstantFor(timeZone, intermediateDateTime, "compatible").
  299. auto* intermediate_instant = TRY(builtin_time_zone_get_instant_for(global_object, time_zone, *intermediate_date_time, "compatible"sv));
  300. // 10. Return ! AddInstant(intermediateInstant.[[Nanoseconds]], hours, minutes, seconds, milliseconds, microseconds, nanoseconds).
  301. return MUST(add_instant(global_object, intermediate_instant->nanoseconds(), hours, minutes, seconds, milliseconds, microseconds, nanoseconds));
  302. }
  303. // 6.5.7 NanosecondsToDays ( nanoseconds, relativeTo ), https://tc39.es/proposal-temporal/#sec-temporal-nanosecondstodays
  304. ThrowCompletionOr<NanosecondsToDaysResult> nanoseconds_to_days(GlobalObject& global_object, BigInt const& nanoseconds_bigint, Value relative_to_value)
  305. {
  306. auto& vm = global_object.vm();
  307. // 1. Assert: Type(nanoseconds) is BigInt.
  308. // 2. Set nanoseconds to ℝ(nanoseconds).
  309. auto nanoseconds = nanoseconds_bigint.big_integer();
  310. // 3. Let sign be ! ℝ(Sign(𝔽(nanoseconds))).
  311. auto sign = Temporal::sign(nanoseconds);
  312. // 4. Let dayLengthNs be 8.64 × 10^13.
  313. auto day_length_ns = "86400000000000"_sbigint;
  314. // 5. If sign is 0, then
  315. if (sign == 0) {
  316. // a. Return the Record { [[Days]]: 0, [[Nanoseconds]]: 0, [[DayLength]]: dayLengthNs }.
  317. return NanosecondsToDaysResult { .days = 0, .nanoseconds = make_handle(js_bigint(vm, { 0 })), .day_length = day_length_ns.to_double() };
  318. }
  319. // 6. If Type(relativeTo) is not Object or relativeTo does not have an [[InitializedTemporalZonedDateTime]] internal slot, then
  320. if (!relative_to_value.is_object() || !is<ZonedDateTime>(relative_to_value.as_object())) {
  321. // a. Return the Record { [[Days]]: the integral part of nanoseconds / dayLengthNs, [[Nanoseconds]]: (abs(nanoseconds) modulo dayLengthNs) × sign, [[DayLength]]: dayLengthNs }.
  322. return NanosecondsToDaysResult {
  323. .days = nanoseconds.divided_by(day_length_ns).quotient.to_double(),
  324. .nanoseconds = make_handle(js_bigint(vm, Crypto::SignedBigInteger { nanoseconds.unsigned_value() }.divided_by(day_length_ns).remainder.multiplied_by(Crypto::SignedBigInteger { (i32)sign }))),
  325. .day_length = day_length_ns.to_double()
  326. };
  327. }
  328. auto& relative_to = static_cast<ZonedDateTime&>(relative_to_value.as_object());
  329. // 7. Let startNs be ℝ(relativeTo.[[Nanoseconds]]).
  330. auto& start_ns = relative_to.nanoseconds().big_integer();
  331. // 8. Let startInstant be ! CreateTemporalInstant(ℤ(startNs)).
  332. auto* start_instant = MUST(create_temporal_instant(global_object, *js_bigint(vm, start_ns)));
  333. // 9. Let startDateTime be ? BuiltinTimeZoneGetPlainDateTimeFor(relativeTo.[[TimeZone]], startInstant, relativeTo.[[Calendar]]).
  334. auto* start_date_time = TRY(builtin_time_zone_get_plain_date_time_for(global_object, &relative_to.time_zone(), *start_instant, relative_to.calendar()));
  335. // 10. Let endNs be startNs + nanoseconds.
  336. auto end_ns = start_ns.plus(nanoseconds);
  337. // 11. Let endInstant be ! CreateTemporalInstant(ℤ(endNs)).
  338. auto* end_instant = MUST(create_temporal_instant(global_object, *js_bigint(vm, end_ns)));
  339. // 12. Let endDateTime be ? BuiltinTimeZoneGetPlainDateTimeFor(relativeTo.[[TimeZone]], endInstant, relativeTo.[[Calendar]]).
  340. auto* end_date_time = TRY(builtin_time_zone_get_plain_date_time_for(global_object, &relative_to.time_zone(), *end_instant, relative_to.calendar()));
  341. // 13. Let dateDifference be ? DifferenceISODateTime(startDateTime.[[ISOYear]], startDateTime.[[ISOMonth]], startDateTime.[[ISODay]], startDateTime.[[ISOHour]], startDateTime.[[ISOMinute]], startDateTime.[[ISOSecond]], startDateTime.[[ISOMillisecond]], startDateTime.[[ISOMicrosecond]], startDateTime.[[ISONanosecond]], endDateTime.[[ISOYear]], endDateTime.[[ISOMonth]], endDateTime.[[ISODay]], endDateTime.[[ISOHour]], endDateTime.[[ISOMinute]], endDateTime.[[ISOSecond]], endDateTime.[[ISOMillisecond]], endDateTime.[[ISOMicrosecond]], endDateTime.[[ISONanosecond]], relativeTo.[[Calendar]], "day").
  342. auto date_difference = TRY(difference_iso_date_time(global_object, start_date_time->iso_year(), start_date_time->iso_month(), start_date_time->iso_day(), start_date_time->iso_hour(), start_date_time->iso_minute(), start_date_time->iso_second(), start_date_time->iso_millisecond(), start_date_time->iso_microsecond(), start_date_time->iso_nanosecond(), end_date_time->iso_year(), end_date_time->iso_month(), end_date_time->iso_day(), end_date_time->iso_hour(), end_date_time->iso_minute(), end_date_time->iso_second(), end_date_time->iso_millisecond(), end_date_time->iso_microsecond(), end_date_time->iso_nanosecond(), relative_to.calendar(), "day"sv));
  343. // 14. Let days be dateDifference.[[Days]].
  344. auto days = date_difference.days;
  345. // 15. Let intermediateNs be ℝ(? AddZonedDateTime(ℤ(startNs), relativeTo.[[TimeZone]], relativeTo.[[Calendar]], 0, 0, 0, days, 0, 0, 0, 0, 0, 0)).
  346. auto intermediate_ns = TRY(add_zoned_date_time(global_object, *js_bigint(vm, start_ns), &relative_to.time_zone(), relative_to.calendar(), 0, 0, 0, days, 0, 0, 0, 0, 0, 0))->big_integer();
  347. // 16. If sign is 1, then
  348. if (sign == 1) {
  349. // a. Repeat, while days > 0 and intermediateNs > endNs,
  350. while (days > 0 && intermediate_ns > end_ns) {
  351. // i. Set days to days − 1.
  352. days--;
  353. // ii. Set intermediateNs to ℝ(? AddZonedDateTime(ℤ(startNs), relativeTo.[[TimeZone]], relativeTo.[[Calendar]], 0, 0, 0, days, 0, 0, 0, 0, 0, 0)).
  354. intermediate_ns = TRY(add_zoned_date_time(global_object, *js_bigint(vm, start_ns), &relative_to.time_zone(), relative_to.calendar(), 0, 0, 0, days, 0, 0, 0, 0, 0, 0))->big_integer();
  355. }
  356. }
  357. // 17. Set nanoseconds to endNs − intermediateNs.
  358. nanoseconds = end_ns.minus(intermediate_ns);
  359. // 18. Let done be false.
  360. // 19. Repeat, while done is false,
  361. while (true) {
  362. // a. Let oneDayFartherNs be ℝ(? AddZonedDateTime(ℤ(intermediateNs), relativeTo.[[TimeZone]], relativeTo.[[Calendar]], 0, 0, 0, sign, 0, 0, 0, 0, 0, 0)).
  363. auto one_day_farther_ns = TRY(add_zoned_date_time(global_object, *js_bigint(vm, intermediate_ns), &relative_to.time_zone(), relative_to.calendar(), 0, 0, 0, sign, 0, 0, 0, 0, 0, 0))->big_integer();
  364. // b. Set dayLengthNs to oneDayFartherNs − intermediateNs.
  365. day_length_ns = one_day_farther_ns.minus(intermediate_ns);
  366. // c. If (nanoseconds − dayLengthNs) × sign ≥ 0, then
  367. if (nanoseconds.minus(day_length_ns).multiplied_by(Crypto::SignedBigInteger { (i32)sign }) >= "0"_sbigint) {
  368. // i. Set nanoseconds to nanoseconds − dayLengthNs.
  369. nanoseconds = nanoseconds.minus(day_length_ns);
  370. // ii. Set intermediateNs to oneDayFartherNs.
  371. intermediate_ns = move(one_day_farther_ns);
  372. // iii. Set days to days + sign.
  373. days += sign;
  374. }
  375. // d. Else,
  376. else {
  377. // i. Set done to true.
  378. break;
  379. }
  380. }
  381. // 20. Return the Record { [[Days]]: days, [[Nanoseconds]]: nanoseconds, [[DayLength]]: abs(dayLengthNs) }.
  382. return NanosecondsToDaysResult { .days = days, .nanoseconds = make_handle(js_bigint(vm, move(nanoseconds))), .day_length = fabs(day_length_ns.to_double()) };
  383. }
  384. }