1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ecmascript/builtins/builtins_relative_time_format.h"
17 
18 namespace panda::ecmascript::builtins {
RelativeTimeFormatConstructor(EcmaRuntimeCallInfo *argv)19 JSTaggedValue BuiltinsRelativeTimeFormat::RelativeTimeFormatConstructor(EcmaRuntimeCallInfo *argv)
20 {
21     JSThread *thread = argv->GetThread();
22     BUILTINS_API_TRACE(thread, RelativeTimeFormat, Constructor);
23     [[maybe_unused]] EcmaHandleScope scope(thread);
24     EcmaVM *ecmaVm = thread->GetEcmaVM();
25     JSHandle<GlobalEnv> env = ecmaVm->GetGlobalEnv();
26     ObjectFactory *factory = ecmaVm->GetFactory();
27 
28     // 1. If NewTarget is undefined, throw a TypeError exception.
29     JSHandle<JSTaggedValue> newTarget = GetNewTarget(argv);
30     if (newTarget->IsUndefined()) {
31         THROW_TYPE_ERROR_AND_RETURN(thread, "newTarget is undefined", JSTaggedValue::Exception());
32     }
33 
34     // 2. Let relativeTimeFormat be ? OrdinaryCreateFromConstructor
35     // (NewTarget, "%RelativeTimeFormatPrototype%", « [[InitializedRelativeTimeFormat]],
36     // [[Locale]], [[DataLocale]], [[Style]], [[Numeric]], [[NumberFormat]], [[NumberingSystem]], [[PluralRules]] »).
37     JSHandle<JSTaggedValue> constructor = GetConstructor(argv);
38     JSHandle<JSObject> newObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(constructor), newTarget);
39     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
40     JSHandle<JSRelativeTimeFormat> relativeTimeFormat = JSHandle<JSRelativeTimeFormat>::Cast(newObject);
41 
42     // 3. Perform ? InitializeRelativeTimeFormat(relativeTimeFormat, locales, options).
43     JSHandle<JSTaggedValue> locales = GetCallArg(argv, 0);
44     JSHandle<JSTaggedValue> options = GetCallArg(argv, 1);
45     JSRelativeTimeFormat::InitializeRelativeTimeFormat(thread, relativeTimeFormat, locales, options);
46     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
47 
48     // 4.  Intl.RelativeTimeFormat.prototype[ @@toStringTag ]
49     // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
50     JSHandle<JSTaggedValue> thisValue = GetThis(argv);
51     bool isInstanceOf = JSObject::InstanceOf(thread, thisValue, env->GetRelativeTimeFormatFunction());
52     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
53     if (newTarget->IsUndefined() && thisValue->IsJSObject() && isInstanceOf) {
54         PropertyDescriptor descriptor(thread, JSHandle<JSTaggedValue>::Cast(relativeTimeFormat), false, false, true);
55         JSHandle<JSTaggedValue> key(thread, JSHandle<JSIntl>::Cast(env->GetIntlFunction())->GetFallbackSymbol());
56         JSTaggedValue::DefinePropertyOrThrow(thread, thisValue, key, descriptor);
57         RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
58         return thisValue.GetTaggedValue();
59     }
60 
61     return relativeTimeFormat.GetTaggedValue();
62 }
63 
SupportedLocalesOf(EcmaRuntimeCallInfo *argv)64 JSTaggedValue BuiltinsRelativeTimeFormat::SupportedLocalesOf(EcmaRuntimeCallInfo *argv)
65 {
66     JSThread *thread = argv->GetThread();
67     BUILTINS_API_TRACE(thread, RelativeTimeFormat, SupportedLocalesOf);
68     [[maybe_unused]] EcmaHandleScope scope(thread);
69 
70     // 1. Let availableLocales be %RelativeTimeFormat%.[[AvailableLocales]].
71     std::vector<std::string> availableStringLocales =
72         intl::LocaleHelper::GetAvailableLocales(thread, "calendar", nullptr);
73     JSHandle<TaggedArray> availableLocales = JSLocale::ConstructLocaleList(thread, availableStringLocales);
74 
75     // 2. Let requestedLocales be ? CanonicalizeLocaleList(locales).
76     JSHandle<JSTaggedValue> locales = GetCallArg(argv, 0);
77     JSHandle<TaggedArray> requestedLocales = intl::LocaleHelper::CanonicalizeLocaleList(thread, locales);
78     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
79 
80     // 3. Return ? SupportedLocales(availableLocales, requestedLocales, options).
81     JSHandle<JSTaggedValue> options = GetCallArg(argv, 1);
82     JSHandle<JSArray> result = JSLocale::SupportedLocales(thread, availableLocales, requestedLocales, options);
83     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
84     return result.GetTaggedValue();
85 }
86 
Format(EcmaRuntimeCallInfo *argv)87 JSTaggedValue BuiltinsRelativeTimeFormat::Format(EcmaRuntimeCallInfo *argv)
88 {
89     JSThread *thread = argv->GetThread();
90     BUILTINS_API_TRACE(thread, RelativeTimeFormat, Format);
91     [[maybe_unused]] EcmaHandleScope scope(thread);
92 
93     // 1. Let relativeTimeFormat be the this value.
94     JSHandle<JSTaggedValue> thisValue = GetThis(argv);
95 
96     // 2. Perform ? RequireInternalSlot(relativeTimeFormat, [[InitializedRelativeTimeFormat]]).
97     if (!thisValue->IsJSRelativeTimeFormat()) {
98         THROW_TYPE_ERROR_AND_RETURN(thread, "this is not rtf object", JSTaggedValue::Exception());
99     }
100 
101     // 3. Let value be ? ToNumber(value).
102     double x = 0.0;
103     JSHandle<JSTaggedValue> value = GetCallArg(argv, 0);
104     JSTaggedNumber temp = JSTaggedValue::ToNumber(thread, value);
105     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
106     x = temp.GetNumber();
107 
108     // 4. Let unit be ? ToString(unit).
109     JSHandle<JSTaggedValue> unitValue = GetCallArg(argv, 1);
110     JSHandle<EcmaString> unit = JSTaggedValue::ToString(thread, unitValue);
111     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
112 
113     // 5. Return ? FormatRelativeTime(relativeTimeFormat, value, unit).
114     JSHandle<JSRelativeTimeFormat> relativeTimeFormat = JSHandle<JSRelativeTimeFormat>::Cast(thisValue);
115     JSHandle<EcmaString> result = JSRelativeTimeFormat::Format(thread, x, unit, relativeTimeFormat);
116     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
117     return result.GetTaggedValue();
118 }
119 
FormatToParts(EcmaRuntimeCallInfo *argv)120 JSTaggedValue BuiltinsRelativeTimeFormat::FormatToParts(EcmaRuntimeCallInfo *argv)
121 {
122     JSThread *thread = argv->GetThread();
123     BUILTINS_API_TRACE(thread, RelativeTimeFormat, FormatToParts);
124     [[maybe_unused]] EcmaHandleScope scope(thread);
125 
126     // 1. Let relativeTimeFormat be the this value.
127     JSHandle<JSTaggedValue> thisValue = GetThis(argv);
128 
129     // 2. Perform ? RequireInternalSlot(relativeTimeFormat, [[InitializedRelativeTimeFormat]]).
130     if (!thisValue->IsJSRelativeTimeFormat()) {
131         THROW_TYPE_ERROR_AND_RETURN(thread, "this is not rtf object", JSTaggedValue::Exception());
132     }
133 
134     // 3. Let value be ? ToNumber(value).
135     double x = 0.0;
136     JSHandle<JSTaggedValue> value = GetCallArg(argv, 0);
137     JSTaggedNumber temp = JSTaggedValue::ToNumber(thread, value);
138     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
139     x = temp.GetNumber();
140 
141     // 4. Let unit be ? ToString(unit).
142     JSHandle<JSTaggedValue> unitValue = GetCallArg(argv, 1);
143     JSHandle<EcmaString> unit = JSTaggedValue::ToString(thread, unitValue);
144     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
145 
146     // 5. Return ? FormatRelativeTime(relativeTimeFormat, value, unit).
147     JSHandle<JSRelativeTimeFormat> relativeTimeFormat = JSHandle<JSRelativeTimeFormat>::Cast(thisValue);
148     JSHandle<JSArray> result = JSRelativeTimeFormat::FormatToParts(thread, x, unit, relativeTimeFormat);
149     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
150     return result.GetTaggedValue();
151 }
152 
ResolvedOptions(EcmaRuntimeCallInfo *argv)153 JSTaggedValue BuiltinsRelativeTimeFormat::ResolvedOptions(EcmaRuntimeCallInfo *argv)
154 {
155     JSThread *thread = argv->GetThread();
156     BUILTINS_API_TRACE(thread, RelativeTimeFormat, ResolvedOptions);
157     [[maybe_unused]] EcmaHandleScope scope(thread);
158 
159     // 1. Let relativeTimeFormat be the this value.
160     JSHandle<JSTaggedValue> thisValue = GetThis(argv);
161 
162     // 2. Perform ? RequireInternalSlot(relativeTimeFormat, [[InitializedRelativeTimeFormat]]).
163     if (!thisValue->IsJSRelativeTimeFormat()) {
164         THROW_TYPE_ERROR_AND_RETURN(thread, "this is not rtf object", JSTaggedValue::Exception());
165     }
166 
167     // 3. Let options be ! ObjectCreate(%ObjectPrototype%).
168     auto ecmaVm = thread->GetEcmaVM();
169     JSHandle<GlobalEnv> env = ecmaVm->GetGlobalEnv();
170     ObjectFactory *factory = ecmaVm->GetFactory();
171     JSHandle<JSFunction> ctor(env->GetObjectFunction());
172     JSHandle<JSObject> options(factory->NewJSObjectByConstructor(ctor));
173 
174     // 4. perform resolvedOptions
175     JSHandle<JSRelativeTimeFormat> relativeTimeFormat = JSHandle<JSRelativeTimeFormat>::Cast(thisValue);
176     JSRelativeTimeFormat::ResolvedOptions(thread, relativeTimeFormat, options);
177     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
178     // 5. Return options.
179     return options.GetTaggedValue();
180 }
181 }  // namespace panda::ecmascript::builtins