diff options
Diffstat (limited to 'Userland/Libraries/LibJS/Runtime')
5 files changed, 230 insertions, 1 deletions
diff --git a/Userland/Libraries/LibJS/Runtime/ErrorTypes.h b/Userland/Libraries/LibJS/Runtime/ErrorTypes.h index acb521a6e2..b29a550493 100644 --- a/Userland/Libraries/LibJS/Runtime/ErrorTypes.h +++ b/Userland/Libraries/LibJS/Runtime/ErrorTypes.h @@ -39,8 +39,10 @@ M(IntlInvalidDateTimeFormatOption, "Option {} cannot be set when also providing {}") \ M(IntlInvalidLanguageTag, "{} is not a structurally valid language tag") \ M(IntlInvalidTime, "Time value must be between -8.64E15 and 8.64E15") \ + M(IntlInvalidUnit, "Unit {} is not a valid time unit") \ M(IntlStartTimeAfterEndTime, "Start time {} is after end time {}") \ M(IntlMinimumExceedsMaximum, "Minimum value {} is larger than maximum value {}") \ + M(IntlNumberIsNaNOrInfinity, "Number must not be NaN or Infinity") \ M(IntlNumberIsNaNOrOutOfRange, "Value {} is NaN or is not between {} and {}") \ M(IntlOptionUndefined, "Option {} must be defined when option {} is {}") \ M(InvalidAssignToConst, "Invalid assignment to const variable") \ diff --git a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp index 9866765b70..c2653605cc 100644 --- a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp +++ b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp @@ -4,12 +4,13 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include <AK/StringBuilder.h> #include <LibJS/Runtime/AbstractOperations.h> #include <LibJS/Runtime/GlobalObject.h> -#include <LibJS/Runtime/Intl/AbstractOperations.h> #include <LibJS/Runtime/Intl/NumberFormat.h> #include <LibJS/Runtime/Intl/NumberFormatConstructor.h> #include <LibJS/Runtime/Intl/RelativeTimeFormat.h> +#include <LibUnicode/NumberFormat.h> namespace JS::Intl { @@ -122,4 +123,194 @@ ThrowCompletionOr<RelativeTimeFormat*> initialize_relative_time_format(GlobalObj return &relative_time_format; } +// 17.1.2 SingularRelativeTimeUnit ( unit ), https://tc39.es/ecma402/#sec-singularrelativetimeunit +ThrowCompletionOr<Unicode::TimeUnit> singular_relative_time_unit(GlobalObject& global_object, StringView unit) +{ + auto& vm = global_object.vm(); + + // 1. Assert: Type(unit) is String. + + // 2. If unit is "seconds", return "second". + if (unit == "seconds"sv) + return Unicode::TimeUnit::Second; + // 3. If unit is "minutes", return "minute". + if (unit == "minutes"sv) + return Unicode::TimeUnit::Minute; + // 4. If unit is "hours", return "hour". + if (unit == "hours"sv) + return Unicode::TimeUnit::Hour; + // 5. If unit is "days", return "day". + if (unit == "days"sv) + return Unicode::TimeUnit::Day; + // 6. If unit is "weeks", return "week". + if (unit == "weeks"sv) + return Unicode::TimeUnit::Week; + // 7. If unit is "months", return "month". + if (unit == "months"sv) + return Unicode::TimeUnit::Month; + // 8. If unit is "quarters", return "quarter". + if (unit == "quarters"sv) + return Unicode::TimeUnit::Quarter; + // 9. If unit is "years", return "year". + if (unit == "years"sv) + return Unicode::TimeUnit::Year; + + // 10. If unit is not one of "second", "minute", "hour", "day", "week", "month", "quarter", or "year", throw a RangeError exception. + // 11. Return unit. + if (auto time_unit = Unicode::time_unit_from_string(unit); time_unit.has_value()) + return *time_unit; + return vm.throw_completion<RangeError>(global_object, ErrorType::IntlInvalidUnit, unit); +} + +// 17.1.3 PartitionRelativeTimePattern ( relativeTimeFormat, value, unit ), https://tc39.es/ecma402/#sec-PartitionRelativeTimePattern +ThrowCompletionOr<Vector<PatternPartitionWithUnit>> partition_relative_time_pattern(GlobalObject& global_object, RelativeTimeFormat& relative_time_format, double value, StringView unit) +{ + auto& vm = global_object.vm(); + + // 1. Assert: relativeTimeFormat has an [[InitializedRelativeTimeFormat]] internal slot. + // 2. Assert: Type(value) is Number. + // 3. Assert: Type(unit) is String. + + // 4. If value is NaN, +∞𝔽, or -∞𝔽, throw a RangeError exception. + if (!Value(value).is_finite_number()) + return vm.throw_completion<RangeError>(global_object, ErrorType::IntlNumberIsNaNOrInfinity); + + // 5. Let unit be ? SingularRelativeTimeUnit(unit). + auto time_unit = TRY(singular_relative_time_unit(global_object, unit)); + + // 6. Let localeData be %RelativeTimeFormat%.[[LocaleData]]. + // 7. Let dataLocale be relativeTimeFormat.[[DataLocale]]. + auto const& data_locale = relative_time_format.data_locale(); + + // 8. Let fields be localeData.[[<dataLocale>]]. + + // 9. Let style be relativeTimeFormat.[[Style]]. + auto style = relative_time_format.style(); + + // NOTE: The next steps form a "key" based on combining various formatting options into a string, + // then filtering the large set of locale data down to the pattern we are looking for. Instead, + // LibUnicode expects the individual options as enumeration values, and returns the couple of + // patterns that match those options. + auto find_patterns_for_tense_or_number = [&](StringView tense_or_number) { + // 10. If style is equal to "short", then + // a. Let entry be the string-concatenation of unit and "-short". + // 11. Else if style is equal to "narrow", then + // a. Let entry be the string-concatenation of unit and "-narrow". + // 12. Else, + // a. Let entry be unit. + auto patterns = Unicode::get_relative_time_format_patterns(data_locale, time_unit, tense_or_number, style); + + // 13. If fields doesn't have a field [[<entry>]], then + if (patterns.is_empty()) { + // a. Let entry be unit. + // NOTE: In the CLDR, the lack of "short" or "narrow" in the key implies "long". + patterns = Unicode::get_relative_time_format_patterns(data_locale, time_unit, tense_or_number, Unicode::Style::Long); + } + + // 14. Let patterns be fields.[[<entry>]]. + return patterns; + }; + + // 15. Let numeric be relativeTimeFormat.[[Numeric]]. + // 16. If numeric is equal to "auto", then + if (relative_time_format.numeric() == RelativeTimeFormat::Numeric::Auto) { + // a. Let valueString be ToString(value). + auto value_string = MUST(Value(value).to_string(global_object)); + + // b. If patterns has a field [[<valueString>]], then + if (auto patterns = find_patterns_for_tense_or_number(value_string); !patterns.is_empty()) { + VERIFY(patterns.size() == 1); + + // i. Let result be patterns.[[<valueString>]]. + auto result = patterns[0].pattern.to_string(); + + // ii. Return a List containing the Record { [[Type]]: "literal", [[Value]]: result }. + return Vector<PatternPartitionWithUnit> { { "literal"sv, move(result) } }; + } + } + + // 17. If value is -0𝔽 or if value is less than 0, then + StringView tense; + if (Value(value).is_negative_zero() || (value < 0)) { + // a. Let tl be "past". + tense = "past"sv; + + // FIXME: The spec does not say to do this, but nothing makes sense after this with a negative value. + value = fabs(value); + } + // 18. Else, + else { + // a. Let tl be "future". + tense = "future"sv; + } + + // 19. Let po be patterns.[[<tl>]]. + auto patterns = find_patterns_for_tense_or_number(tense); + + // 20. Let fv be ! PartitionNumberPattern(relativeTimeFormat.[[NumberFormat]], value). + auto value_partitions = partition_number_pattern(relative_time_format.number_format(), value); + + // 21. Let pr be ! ResolvePlural(relativeTimeFormat.[[PluralRules]], value). + // 22. Let pattern be po.[[<pr>]]. + // FIXME: Use ResolvePlural when Intl.PluralRules is implemented. + auto pattern = Unicode::select_pattern_with_plurality(patterns, value); + if (!pattern.has_value()) + return Vector<PatternPartitionWithUnit> {}; + + // 23. Return ! MakePartsList(pattern, unit, fv). + return make_parts_list(pattern->pattern, Unicode::time_unit_to_string(time_unit), move(value_partitions)); +} + +// 17.1.4 MakePartsList ( pattern, unit, parts ), https://tc39.es/ecma402/#sec-makepartslist +Vector<PatternPartitionWithUnit> make_parts_list(StringView pattern, StringView unit, Vector<PatternPartition> parts) +{ + // 1. Let patternParts be PartitionPattern(pattern). + auto pattern_parts = partition_pattern(pattern); + + // 2. Let result be a new empty List. + Vector<PatternPartitionWithUnit> result; + + // 3. For each Record { [[Type]], [[Value]] } patternPart in patternParts, do + for (auto& pattern_part : pattern_parts) { + // a. If patternPart.[[Type]] is "literal", then + if (pattern_part.type == "literal"sv) { + // i. Append Record { [[Type]]: "literal", [[Value]]: patternPart.[[Value]], [[Unit]]: empty } to result. + result.empend("literal"sv, move(pattern_part.value)); + } + // b. Else, + else { + // i. Assert: patternPart.[[Type]] is "0". + VERIFY(pattern_part.type == "0"sv); + + // ii. For each Record { [[Type]], [[Value]] } part in parts, do + for (auto& part : parts) { + // 1. Append Record { [[Type]]: part.[[Type]], [[Value]]: part.[[Value]], [[Unit]]: unit } to result. + result.empend(part.type, move(part.value), unit); + } + } + } + + // 4. Return result. + return result; +} + +// 17.1.5 FormatRelativeTime ( relativeTimeFormat, value, unit ), https://tc39.es/ecma402/#sec-FormatRelativeTime +ThrowCompletionOr<String> format_relative_time(GlobalObject& global_object, RelativeTimeFormat& relative_time_format, double value, StringView unit) +{ + // 1. Let parts be ? PartitionRelativeTimePattern(relativeTimeFormat, value, unit). + auto parts = TRY(partition_relative_time_pattern(global_object, relative_time_format, value, unit)); + + // 2. Let result be an empty String. + StringBuilder result; + + // 3. For each Record { [[Type]], [[Value]], [[Unit]] } part in parts, do + for (auto& part : parts) { + // a. Set result to the string-concatenation of result and part.[[Value]]. + result.append(move(part.value)); + } + + // 4. Return result. + return result.build(); +} + } diff --git a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h index 134819cae9..e19ea4bd3e 100644 --- a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h +++ b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h @@ -10,8 +10,10 @@ #include <AK/String.h> #include <AK/StringView.h> #include <LibJS/Runtime/Completion.h> +#include <LibJS/Runtime/Intl/AbstractOperations.h> #include <LibJS/Runtime/Object.h> #include <LibUnicode/Locale.h> +#include <LibUnicode/RelativeTimeFormat.h> namespace JS::Intl { @@ -65,6 +67,20 @@ private: NumberFormat* m_number_format { nullptr }; // [[NumberFormat]] }; +struct PatternPartitionWithUnit : public PatternPartition { + PatternPartitionWithUnit(StringView type, String value, StringView unit_string = {}) + : PatternPartition(type, move(value)) + , unit(unit_string) + { + } + + StringView unit; +}; + ThrowCompletionOr<RelativeTimeFormat*> initialize_relative_time_format(GlobalObject& global_object, RelativeTimeFormat& relative_time_format, Value locales_value, Value options_value); +ThrowCompletionOr<Unicode::TimeUnit> singular_relative_time_unit(GlobalObject& global_object, StringView unit); +ThrowCompletionOr<Vector<PatternPartitionWithUnit>> partition_relative_time_pattern(GlobalObject& global_object, RelativeTimeFormat& relative_time_format, double value, StringView unit); +Vector<PatternPartitionWithUnit> make_parts_list(StringView pattern, StringView unit, Vector<PatternPartition> parts); +ThrowCompletionOr<String> format_relative_time(GlobalObject& global_object, RelativeTimeFormat& relative_time_format, double value, StringView unit); } diff --git a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp index e61f12f97f..b0c152cf9e 100644 --- a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp +++ b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp @@ -25,9 +25,28 @@ void RelativeTimeFormatPrototype::initialize(GlobalObject& global_object) define_direct_property(*vm.well_known_symbol_to_string_tag(), js_string(vm, "Intl.RelativeTimeFormat"sv), Attribute::Configurable); u8 attr = Attribute::Writable | Attribute::Configurable; + define_native_function(vm.names.format, format, 2, attr); define_native_function(vm.names.resolvedOptions, resolved_options, 0, attr); } +// 17.4.3 Intl.RelativeTimeFormat.prototype.format ( value, unit ), https://tc39.es/ecma402/#sec-Intl.RelativeTimeFormat.prototype.format +JS_DEFINE_NATIVE_FUNCTION(RelativeTimeFormatPrototype::format) +{ + // 1. Let relativeTimeFormat be the this value. + // 2. Perform ? RequireInternalSlot(relativeTimeFormat, [[InitializedRelativeTimeFormat]]). + auto* relative_time_format = TRY(typed_this_object(global_object)); + + // 3. Let value be ? ToNumber(value). + auto value = TRY(vm.argument(0).to_number(global_object)); + + // 4. Let unit be ? ToString(unit). + auto unit = TRY(vm.argument(1).to_string(global_object)); + + // 5. Return ? FormatRelativeTime(relativeTimeFormat, value, unit). + auto formatted = TRY(format_relative_time(global_object, *relative_time_format, value.as_double(), unit)); + return js_string(vm, move(formatted)); +} + // 17.4.5 Intl.RelativeTimeFormat.prototype.resolvedOptions ( ), https://tc39.es/ecma402/#sec-intl.relativetimeformat.prototype.resolvedoptions JS_DEFINE_NATIVE_FUNCTION(RelativeTimeFormatPrototype::resolved_options) { diff --git a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h index 5df2a3d52b..c7dbf0eabf 100644 --- a/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h +++ b/Userland/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h @@ -20,6 +20,7 @@ public: virtual ~RelativeTimeFormatPrototype() override = default; private: + JS_DECLARE_NATIVE_FUNCTION(format); JS_DECLARE_NATIVE_FUNCTION(resolved_options); }; |