1 /* 2 * Copyright (c) 2022 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 "commonlibrary/ets_utils/js_util_module/util/js_base64.h" 17 #include "commonlibrary/ets_utils/js_util_module/util/js_textdecoder.h" 18 #include "commonlibrary/ets_utils/js_util_module/util/js_textencoder.h" 19 #include "commonlibrary/ets_utils/js_util_module/util/js_types.h" 20 #include "commonlibrary/ets_utils/js_util_module/util/js_uuid.h" 21 #include "commonlibrary/ets_utils/js_util_module/util/js_stringdecoder.h" 22 23 #include "securec.h" 24 #include "tools/log.h" 25 26 #include "jni_helper.h" 27 28 extern const char _binary_util_js_js_start[]; 29 extern const char _binary_util_js_js_end[]; 30 extern const char _binary_util_abc_start[]; 31 extern const char _binary_util_abc_end[]; 32 static const std::vector<std::string> conventFormat = {"utf-8", "UTF-8", "gbk", "GBK", "GB2312", "gb2312", 33 "GB18030", "gb18030", "ibm866", "iso-8859-2", "iso-8859-3", 34 "iso-8859-4", "iso-8859-5", "iso-8859-6", "iso-8859-7", 35 "iso-8859-8", "iso-8859-8-i", "iso-8859-10", "iso-8859-13", 36 "iso-8859-14", "iso-8859-15", "koi8-r", "koi8-u", "macintosh", 37 "windows-874", "windows-1250", "windows-1251", "windows-1252", 38 "windows-1253", "windows-1254", "windows-1255", "windows-1256", 39 "windows-1257", "windows-1258", "big5", "euc-jp", "iso-2022-jp", 40 "shift_jis", "euc-kr", "x-mac-cyrillic", "utf-16be", 41 "utf-16le", "iso-8859-1"}; 42 43 namespace OHOS::Util { 44 using namespace Commonlibrary::Platform; IsValidValue(napi_env env,napi_value value)45 static bool IsValidValue(napi_env env, napi_value value) 46 { 47 napi_value undefinedRef = nullptr; 48 napi_value nullRef = nullptr; 49 napi_get_undefined(env, &undefinedRef); 50 napi_get_null(env, &nullRef); 51 bool isUndefined = false; 52 bool isNull = false; 53 napi_strict_equals(env, value, undefinedRef, &isUndefined); 54 napi_strict_equals(env, value, nullRef, &isNull); 55 return !(isUndefined || isNull); 56 } 57 ApplyMemory(const size_t length)58 static char* ApplyMemory(const size_t length) 59 { 60 if (length == 0) { 61 return nullptr; 62 } 63 char *type = new (std::nothrow) char[length + 1]; 64 if (type == nullptr) { 65 HILOG_ERROR("Textdecoder:: memory allocation failed, type is nullptr"); 66 return nullptr; 67 } 68 if (memset_s(type, length + 1, '\0', length + 1) != EOK) { 69 HILOG_ERROR("Textdecoder:: type memset_s failed"); 70 delete[] type; 71 return nullptr; 72 } 73 return type; 74 } 75 76 static std::string temp = "cdfijoOs"; DealWithPrintf(const std::string & format,const std::vector<std::string> & value)77 static std::string DealWithPrintf(const std::string &format, const std::vector<std::string> &value) 78 { 79 size_t i = 0; 80 size_t j = 0; 81 std::string str; 82 size_t formatSize = format.size(); 83 size_t valueSize = value.size(); 84 while (i < formatSize && j < valueSize) { 85 if (format[i] == '%' && (i + 1 < formatSize && format[i + 1] == '%')) { 86 str += '%'; 87 i += 2; // 2:The array goes back two digits. 88 } else if (format[i] == '%' && (i + 1 < formatSize && (temp.find(format[i + 1])) != std::string::npos)) { 89 if (format[i + 1] == 'c') { 90 j++; 91 } else { 92 str += value[j++]; 93 } 94 i += 2; // 2:The array goes back two digits. 95 } else if (format[i] == '%' && (i + 1 < formatSize && (temp.find(format[i + 1])) == std::string::npos)) { 96 str += '%'; 97 i++; 98 } 99 if (i < formatSize && format[i] != '%') { 100 size_t pos = 0; 101 if ((pos = format.find('%', i)) == std::string::npos) { 102 str += format.substr(i); 103 i = formatSize; 104 break; 105 } else { 106 str += format.substr(i, pos - i); 107 i = pos; 108 } 109 } 110 } 111 while (j < valueSize) { 112 str += " " + value[j++]; 113 } 114 if (i < formatSize) { 115 str += format.substr(i); 116 } 117 return str; 118 } 119 ThrowError(napi_env env,const char * errMessage)120 static napi_value ThrowError(napi_env env, const char* errMessage) 121 { 122 napi_value utilError = nullptr; 123 napi_value code = nullptr; 124 uint32_t errCode = 401; 125 napi_create_uint32(env, errCode, &code); 126 napi_value name = nullptr; 127 std::string errName = "BusinessError"; 128 napi_value msg = nullptr; 129 napi_create_string_utf8(env, errMessage, NAPI_AUTO_LENGTH, &msg); 130 napi_create_string_utf8(env, errName.c_str(), NAPI_AUTO_LENGTH, &name); 131 napi_create_error(env, nullptr, msg, &utilError); 132 napi_set_named_property(env, utilError, "code", code); 133 napi_set_named_property(env, utilError, "name", name); 134 napi_throw(env, utilError); 135 return nullptr; 136 } 137 FormatString(napi_env env,std::string & str)138 static napi_value FormatString(napi_env env, std::string &str) 139 { 140 std::string res; 141 size_t strSize = str.size(); 142 for (size_t i = 0; i < strSize; ++i) { 143 if (str[i] == '%' && (i + 1 < strSize && temp.find(str[i + 1]) != std::string::npos)) { 144 if (str[i + 1] == 'o') { 145 res += "o "; 146 } else if (str[i + 1] == 'O') { 147 res += "O "; 148 } else if (str[i + 1] == 'i') { 149 res += "i "; 150 } else if (str[i + 1] == 'j') { 151 res += "j "; 152 } else if (str[i + 1] == 'd') { 153 res += "d "; 154 } else if (str[i + 1] == 's') { 155 res += "s "; 156 } else if (str[i + 1] == 'f') { 157 res += "f "; 158 } else if (str[i + 1] == 'c') { 159 res += "c "; 160 } 161 i++; 162 } else if (str[i] == '%' && (i + 1 < strSize && str[i + 1] == '%')) { 163 i++; 164 } 165 } 166 if (!res.empty()) { 167 res = res.substr(0, res.size() - 1); 168 } 169 napi_value result = nullptr; 170 napi_create_string_utf8(env, res.c_str(), res.size(), &result); 171 return result; 172 } 173 FreeMemory(napi_value * address)174 static void FreeMemory(napi_value *address) 175 { 176 delete[] address; 177 address = nullptr; 178 } 179 DealWithFormatString(napi_env env,napi_callback_info info)180 static napi_value DealWithFormatString(napi_env env, napi_callback_info info) 181 { 182 size_t argc = 1; 183 napi_value argv = nullptr; 184 napi_get_cb_info(env, info, &argc, 0, nullptr, nullptr); 185 186 napi_get_cb_info(env, info, &argc, &argv, nullptr, nullptr); 187 std::string format = ""; 188 size_t formatsize = 0; 189 if (napi_get_value_string_utf8(env, argv, nullptr, 0, &formatsize) != napi_ok) { 190 HILOG_ERROR("DealWithFormatString:: can not get argv size"); 191 return nullptr; 192 } 193 format.reserve(formatsize + 1); 194 format.resize(formatsize); 195 if (napi_get_value_string_utf8(env, argv, format.data(), formatsize + 1, &formatsize) != napi_ok) { 196 HILOG_ERROR("DealWithFormatString:: can not get argv value"); 197 return nullptr; 198 } 199 return FormatString(env, format); 200 } 201 PrintfString(const std::string & format,const std::vector<std::string> & value)202 static std::string PrintfString(const std::string &format, const std::vector<std::string> &value) 203 { 204 return DealWithPrintf(format, value); 205 } 206 Printf(napi_env env,napi_callback_info info)207 static napi_value Printf(napi_env env, napi_callback_info info) 208 { 209 napi_value result = nullptr; 210 size_t argc = 0; 211 napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); 212 napi_value *argv = nullptr; 213 if (argc > 0) { 214 argv = new (std::nothrow) napi_value[argc]; 215 if (argv == nullptr) { 216 HILOG_ERROR("Printf:: memory allocation failed, argv is nullptr"); 217 return nullptr; 218 } 219 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 220 std::string format = ""; 221 size_t formatsize = 0; 222 if (napi_get_value_string_utf8(env, argv[0], nullptr, 0, &formatsize) != napi_ok) { 223 HILOG_ERROR("Printf:: can not get argv[0] size"); 224 FreeMemory(argv); 225 return nullptr; 226 } 227 format.reserve(formatsize + 1); 228 format.resize(formatsize); 229 if (napi_get_value_string_utf8(env, argv[0], format.data(), formatsize + 1, &formatsize) != napi_ok) { 230 HILOG_ERROR("Printf:: can not get argv[0] value"); 231 FreeMemory(argv); 232 return nullptr; 233 } 234 std::vector<std::string> value; 235 for (size_t i = 1; i < argc; i++) { 236 std::string valueString = ""; 237 size_t valuesize = 0; 238 if (napi_get_value_string_utf8(env, argv[i], nullptr, 0, &valuesize) != napi_ok) { 239 HILOG_ERROR("Printf:: can not get argv[i] size"); 240 FreeMemory(argv); 241 return nullptr; 242 } 243 valueString.reserve(valuesize + 1); 244 valueString.resize(valuesize); 245 if (napi_get_value_string_utf8(env, argv[i], valueString.data(), 246 valuesize + 1, &valuesize) != napi_ok) { 247 HILOG_ERROR("Printf:: can not get argv[i] value"); 248 FreeMemory(argv); 249 return nullptr; 250 } 251 value.push_back(valueString.data()); 252 } 253 std::string printInfo = PrintfString(format.data(), value); 254 napi_create_string_utf8(env, printInfo.c_str(), printInfo.size(), &result); 255 FreeMemory(argv); 256 return result; 257 } 258 napi_value res = nullptr; 259 NAPI_CALL(env, napi_get_undefined(env, &res)); 260 return res; 261 } 262 GetErrorString(napi_env env,napi_callback_info info)263 static napi_value GetErrorString(napi_env env, napi_callback_info info) 264 { 265 napi_value thisVar = nullptr; 266 napi_value result = nullptr; 267 std::string errInfo; 268 size_t argc = 1; 269 napi_value argv = nullptr; 270 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 271 int32_t err = 0; 272 NAPI_CALL(env, napi_get_value_int32(env, argv, &err)); 273 errInfo = uv_strerror(err); 274 NAPI_CALL(env, napi_create_string_utf8(env, errInfo.c_str(), errInfo.size(), &result)); 275 return result; 276 } 277 RandomUUID(napi_env env,napi_callback_info info)278 static napi_value RandomUUID(napi_env env, napi_callback_info info) 279 { 280 napi_value thisVar = nullptr; 281 size_t requireArgc = 1; 282 size_t argc = 1; 283 napi_value args[1] = { 0 }; 284 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 285 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 286 bool flag = false; 287 napi_get_value_bool(env, args[0], &flag); 288 std::string uuidString = OHOS::Util::GetStringUUID(env, flag); 289 napi_value result = nullptr; 290 size_t tempLen = uuidString.size(); 291 napi_create_string_utf8(env, uuidString.c_str(), tempLen, &result); 292 return result; 293 } 294 RandomBinaryUUID(napi_env env,napi_callback_info info)295 static napi_value RandomBinaryUUID(napi_env env, napi_callback_info info) 296 { 297 napi_value thisVar = nullptr; 298 size_t requireArgc = 1; 299 size_t argc = 1; 300 napi_value args[1] = { 0 }; 301 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 302 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 303 bool flag = false; 304 napi_get_value_bool(env, args[0], &flag); 305 napi_value result = OHOS::Util::GetBinaryUUID(env, flag); 306 return result; 307 } 308 ParseUUID(napi_env env,napi_callback_info info)309 static napi_value ParseUUID(napi_env env, napi_callback_info info) 310 { 311 napi_value thisVar = nullptr; 312 size_t requireArgc = 1; 313 size_t argc = 1; 314 napi_value args[1] = { nullptr }; 315 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 316 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 317 napi_valuetype valuetype; 318 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype)); 319 NAPI_ASSERT(env, valuetype == napi_string, "Wrong argument type. String expected."); 320 napi_value result = OHOS::Util::DoParseUUID(env, args[0]); 321 return result; 322 } 323 GetHash(napi_env env,napi_callback_info info)324 static napi_value GetHash(napi_env env, napi_callback_info info) 325 { 326 napi_value thisVar = nullptr; 327 size_t requireArgc = 1; 328 size_t argc = 1; 329 napi_value args[1] = { nullptr }; 330 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 331 if (argc < requireArgc) { 332 napi_throw_error(env, "-1", "Expected 1 parameter, actually not included in the parameter."); 333 return nullptr; 334 } 335 napi_valuetype valuetype; 336 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype)); 337 if (valuetype != napi_object) { 338 return ThrowError(env, "Parameter error. The type of Parameter must be object."); 339 } 340 NativeEngine *engine = reinterpret_cast<NativeEngine*>(env); 341 int32_t value = engine->GetObjectHash(env, args[0]); 342 napi_value result = nullptr; 343 napi_create_uint32(env, value, &result); 344 return result; 345 } 346 GetMainThreadStackTrace(napi_env env,napi_callback_info info)347 static napi_value GetMainThreadStackTrace(napi_env env, [[maybe_unused]] napi_callback_info info) 348 { 349 NativeEngine *engine = reinterpret_cast<NativeEngine*>(env); 350 std::string stackTraceStr; 351 engine->GetMainThreadStackTrace(env, stackTraceStr); 352 napi_value result = nullptr; 353 size_t tempLen = stackTraceStr.size(); 354 napi_create_string_utf8(env, stackTraceStr.c_str(), tempLen, &result); 355 return result; 356 } 357 TextdecoderConstructor(napi_env env,napi_callback_info info)358 static napi_value TextdecoderConstructor(napi_env env, napi_callback_info info) 359 { 360 size_t tempArgc = 0; 361 napi_value thisVar = nullptr; 362 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 363 size_t argc = 0; 364 void *data = nullptr; 365 char *type = nullptr; 366 size_t typeLen = 0; 367 int32_t flags = 0; 368 std::vector<int> paraVec(2, 0); // 2: Specifies the size of the container to be applied for. 369 if (tempArgc == 1) { 370 argc = 1; 371 napi_value argv = nullptr; 372 napi_get_cb_info(env, info, &argc, &argv, nullptr, &data); 373 napi_get_value_string_utf8(env, argv, nullptr, 0, &typeLen); 374 if (typeLen > 0) { 375 type = ApplyMemory(typeLen); 376 } 377 napi_get_value_string_utf8(env, argv, type, typeLen + 1, &typeLen); 378 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 379 argc = 2; // 2: The number of parameters is 2. 380 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 381 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &data); 382 // first para 383 napi_get_value_string_utf8(env, argvArr[0], nullptr, 0, &typeLen); 384 if (typeLen > 0) { 385 type = ApplyMemory(typeLen); 386 } 387 napi_get_value_string_utf8(env, argvArr[0], type, typeLen + 1, &typeLen); 388 napi_get_value_int32(env, argvArr[1], &flags); 389 } 390 std::string enconding = "utf-8"; 391 if (type != nullptr) { 392 enconding = type; 393 } 394 delete []type; 395 type = nullptr; 396 auto objectInfo = new (std::nothrow) TextDecoder(enconding, flags); 397 if (objectInfo == nullptr) { 398 HILOG_ERROR("TextDecoder:: memory allocation failed, objectInfo is nullptr"); 399 return nullptr; 400 } 401 NAPI_CALL(env, napi_wrap( 402 env, thisVar, objectInfo, 403 [](napi_env environment, void *data, void *hint) { 404 auto objInfo = reinterpret_cast<TextDecoder*>(data); 405 if (objInfo != nullptr) { 406 delete objInfo; 407 objInfo = nullptr; 408 } 409 }, 410 nullptr, nullptr)); 411 return thisVar; 412 } 413 DecodeToString(napi_env env,napi_callback_info info)414 static napi_value DecodeToString(napi_env env, napi_callback_info info) 415 { 416 size_t tempArgc = 2; // 2:The number of parameters is 2 417 napi_value thisVar = nullptr; 418 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 419 size_t argc = 0; 420 void *dataPara = nullptr; 421 napi_typedarray_type type; 422 size_t length = 0; 423 void *data = nullptr; 424 napi_value arraybuffer = nullptr; 425 size_t byteOffset = 0; 426 bool iStream = false; 427 TextDecoder *textDecoder = nullptr; 428 napi_unwrap(env, thisVar, (void**)&textDecoder); 429 if (textDecoder == nullptr) { 430 HILOG_ERROR("DecodeToString:: textDecoder is nullptr"); 431 return nullptr; 432 } 433 napi_value valStr = nullptr; 434 if (tempArgc == 1) { 435 argc = 1; 436 napi_value argv = nullptr; 437 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 438 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 439 if (type != napi_uint8_array) { 440 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 441 } 442 valStr = textDecoder->DecodeToString(env, argv, iStream); 443 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 444 argc = 2; // 2: The number of parameters is 2. 445 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 446 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 447 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 448 if (type != napi_uint8_array) { 449 return ThrowError(env, "Parameter error. The type of first Parameter must be Uint8Array."); 450 } 451 napi_valuetype valueType; 452 napi_typeof(env, argvArr[1], &valueType); 453 if (valueType != napi_undefined && valueType != napi_null) { 454 if (valueType != napi_object) { 455 return ThrowError(env, "Parameter error. The type of second Parameter must be object."); 456 } 457 const char *messageKeyStrStream = "stream"; 458 napi_value resultStream = nullptr; 459 napi_get_named_property(env, argvArr[1], messageKeyStrStream, &resultStream); 460 napi_get_value_bool(env, resultStream, &iStream); 461 } 462 valStr = textDecoder->DecodeToString(env, argvArr[0], iStream); 463 } 464 return valStr; 465 } 466 TextdecoderDecode(napi_env env,napi_callback_info info)467 static napi_value TextdecoderDecode(napi_env env, napi_callback_info info) 468 { 469 size_t tempArgc = 2; // 2:The number of parameters is 2 470 napi_value thisVar = nullptr; 471 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 472 size_t argc = 0; 473 void *dataPara = nullptr; 474 napi_typedarray_type type; 475 size_t length = 0; 476 void *data = nullptr; 477 napi_value arraybuffer = nullptr; 478 size_t byteOffset = 0; 479 bool iStream = false; 480 TextDecoder *textDecoder = nullptr; 481 napi_unwrap(env, thisVar, (void**)&textDecoder); 482 if (textDecoder == nullptr) { 483 return nullptr; 484 } 485 napi_value valStr = nullptr; 486 if (tempArgc == 1) { 487 argc = 1; 488 napi_value argv = nullptr; 489 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 490 // first para 491 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 492 if (type != napi_uint8_array) { 493 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 494 } 495 valStr = textDecoder->Decode(env, argv, iStream); 496 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 497 argc = 2; // 2: The number of parameters is 2. 498 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 499 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 500 // first para 501 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 502 // second para 503 if (type != napi_uint8_array) { 504 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 505 } 506 napi_valuetype valueType1; 507 napi_typeof(env, argvArr[1], &valueType1); 508 if (valueType1 != napi_undefined && valueType1 != napi_null) { 509 if (valueType1 != napi_object) { 510 return ThrowError(env, "Parameter error. The type of Parameter must be object."); 511 } 512 napi_value messageKeyStream = nullptr; 513 const char *messageKeyStrStream = "stream"; 514 515 napi_value resultStream = nullptr; 516 NAPI_CALL(env, napi_create_string_utf8(env, messageKeyStrStream, strlen(messageKeyStrStream), 517 &messageKeyStream)); 518 NAPI_CALL(env, napi_get_property(env, argvArr[1], messageKeyStream, &resultStream)); 519 NAPI_CALL(env, napi_get_value_bool(env, resultStream, &iStream)); 520 } 521 valStr = textDecoder->Decode(env, argvArr[0], iStream); 522 } 523 return valStr; 524 } 525 CheckEncodingFormat(const std::string & encoding)526 static bool CheckEncodingFormat(const std::string &encoding) 527 { 528 for (const auto& format : conventFormat) { 529 if (format == encoding) { 530 return true; 531 } 532 } 533 return false; 534 } 535 InitTextEncoder(napi_env env,napi_value thisVar,std::string encoding,std::string orgEncoding)536 static napi_value InitTextEncoder(napi_env env, napi_value thisVar, std::string encoding, std::string orgEncoding) 537 { 538 auto object = new (std::nothrow) TextEncoder(encoding); 539 if (object == nullptr) { 540 HILOG_ERROR("TextEncoder:: memory allocation failed, object is nullptr"); 541 return nullptr; 542 } 543 object->SetOrgEncoding(orgEncoding); 544 napi_status status = napi_wrap(env, thisVar, object, 545 [](napi_env environment, void *data, void *hint) { 546 auto obj = reinterpret_cast<TextEncoder*>(data); 547 if (obj != nullptr) { 548 delete obj; 549 obj = nullptr; 550 } 551 }, nullptr, nullptr); 552 if (status != napi_ok) { 553 delete object; 554 object = nullptr; 555 } 556 return thisVar; 557 } 558 559 // Encoder TextEncoderConstructor(napi_env env,napi_callback_info info)560 static napi_value TextEncoderConstructor(napi_env env, napi_callback_info info) 561 { 562 size_t argc = 0; 563 napi_value thisVar = nullptr; 564 napi_value src = nullptr; 565 napi_get_cb_info(env, info, &argc, &src, &thisVar, nullptr); 566 std::string encoding = "utf-8"; 567 std::string orgEncoding = encoding; 568 if (argc == 1) { 569 napi_get_cb_info(env, info, &argc, &src, nullptr, nullptr); 570 napi_valuetype valuetype; 571 napi_typeof(env, src, &valuetype); 572 if (valuetype != napi_undefined && valuetype != napi_null) { 573 if (valuetype != napi_string) { 574 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 575 } 576 size_t bufferSize = 0; 577 if (napi_get_value_string_utf8(env, src, nullptr, 0, &bufferSize) != napi_ok) { 578 HILOG_ERROR("TextEncoder:: can not get src size"); 579 return nullptr; 580 } 581 std::string buffer = ""; 582 buffer.reserve(bufferSize + 1); 583 buffer.resize(bufferSize, '\0'); 584 if (napi_get_value_string_utf8(env, src, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 585 HILOG_ERROR("TextEncoder:: can not get src value"); 586 return nullptr; 587 } 588 orgEncoding = buffer; 589 for (char &temp : buffer) { 590 temp = std::tolower(static_cast<unsigned char>(temp)); 591 } 592 NAPI_ASSERT(env, CheckEncodingFormat(buffer), 593 "Wrong encoding format, the current encoding format is not support"); 594 encoding = buffer; 595 } 596 } 597 return InitTextEncoder(env, thisVar, encoding, orgEncoding); 598 } 599 GetEncoding(napi_env env,napi_callback_info info)600 static napi_value GetEncoding(napi_env env, napi_callback_info info) 601 { 602 napi_value thisVar = nullptr; 603 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 604 605 TextEncoder *object = nullptr; 606 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 607 608 return object->GetEncoding(env); 609 } 610 Encode(napi_env env,napi_callback_info info)611 static napi_value Encode(napi_env env, napi_callback_info info) 612 { 613 napi_value thisVar = nullptr; 614 size_t requireArgc = 1; 615 size_t argc = 1; 616 napi_value args = nullptr; 617 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 618 NAPI_ASSERT(env, argc <= requireArgc, "Wrong number of arguments"); 619 620 napi_value result; 621 if (argc == 1) { 622 napi_valuetype valuetype; 623 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 624 if (!IsValidValue(env, args)) { 625 napi_get_undefined(env, &result); 626 return result; 627 } 628 NAPI_ASSERT(env, valuetype == napi_string, "Wrong argument type. String expected."); 629 } else { 630 napi_get_undefined(env, &result); 631 return result; 632 } 633 TextEncoder *object = nullptr; 634 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 635 636 result = object->Encode(env, args); 637 638 return result; 639 } 640 EncodeIntoOne(napi_env env,napi_callback_info info)641 static napi_value EncodeIntoOne(napi_env env, napi_callback_info info) 642 { 643 napi_value thisVar = nullptr; 644 // EncodeIntoOne is invoked by EncodeIntoArgs, argc can be 0 or 1 645 // if argc is 0, typeof args is undefined. 646 size_t argc = 1; 647 napi_value args = nullptr; 648 napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr); 649 napi_value result = nullptr; 650 napi_valuetype valuetype; 651 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 652 653 if (valuetype == napi_null || valuetype == napi_undefined) { 654 napi_get_undefined(env, &result); 655 return result; 656 } 657 if (valuetype != napi_string) { 658 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 659 } 660 661 TextEncoder *object = nullptr; 662 NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&object)); 663 result = object->Encode(env, args); 664 return result; 665 } 666 EncodeIntoTwo(napi_env env,napi_callback_info info)667 static napi_value EncodeIntoTwo(napi_env env, napi_callback_info info) 668 { 669 napi_value thisVar = nullptr; 670 size_t requireArgc = 2; // 2:The number of parameters is 2 671 size_t argc = 2; // 2:The number of parameters is 2 672 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 673 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 674 675 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 676 677 napi_valuetype valuetype0; 678 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 679 680 napi_typedarray_type valuetype1; 681 size_t length = 0; 682 void *data = nullptr; 683 napi_value arraybuffer = nullptr; 684 size_t byteOffset = 0; 685 NAPI_CALL(env, napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset)); 686 687 NAPI_ASSERT(env, valuetype0 == napi_string, "Wrong argument type. String expected."); 688 NAPI_ASSERT(env, valuetype1 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 689 690 TextEncoder *object = nullptr; 691 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 692 693 napi_value result = object->EncodeInto(env, args[0], args[1]); 694 695 return result; 696 } 697 EncodeIntoUint8Array(napi_env env,napi_callback_info info)698 static napi_value EncodeIntoUint8Array(napi_env env, napi_callback_info info) 699 { 700 napi_value thisVar = nullptr; 701 size_t argc = 2; // 2:The number of parameters is 2 702 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 703 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 704 napi_valuetype valuetype0; 705 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 706 napi_typedarray_type valuetype1; 707 size_t length = 0; 708 void *data = nullptr; 709 napi_value arraybuffer = nullptr; 710 size_t byteOffset = 0; 711 napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset); 712 if (valuetype0 != napi_string) { 713 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 714 } 715 if (valuetype1 != napi_uint8_array) { 716 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 717 } 718 TextEncoder *object = nullptr; 719 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 720 napi_value result = object->EncodeInto(env, args[0], args[1]); 721 return result; 722 } 723 EncodeIntoArgs(napi_env env,napi_callback_info info)724 static napi_value EncodeIntoArgs(napi_env env, napi_callback_info info) 725 { 726 size_t argc = 0; 727 napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); 728 if (argc >= 2) { // 2:The number of parameters is 2 729 return EncodeIntoTwo(env, info); 730 } 731 return EncodeIntoOne(env, info); 732 } 733 Create(napi_env env,napi_callback_info info)734 static napi_value Create(napi_env env, napi_callback_info info) 735 { 736 napi_value textEncoderObj = TextEncoderConstructor(env, info); 737 napi_property_descriptor textEncoderDesc[] = { 738 DECLARE_NAPI_GETTER("encoding", GetEncoding), 739 DECLARE_NAPI_FUNCTION("encode", Encode), 740 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 741 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 742 }; 743 napi_define_properties(env, textEncoderObj, sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 744 textEncoderDesc); 745 return textEncoderObj; 746 } 747 TextcoderInit(napi_env env,napi_value exports)748 static napi_value TextcoderInit(napi_env env, napi_value exports) 749 { 750 const char *textEncoderClassName = "TextEncoder"; 751 napi_value textEncoderClass = nullptr; 752 napi_property_descriptor textEncoderDesc[] = { 753 DECLARE_NAPI_GETTER("encoding", GetEncoding), 754 DECLARE_NAPI_FUNCTION("encode", Encode), 755 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 756 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 757 DECLARE_NAPI_STATIC_FUNCTION("create", Create), 758 759 }; 760 NAPI_CALL(env, napi_define_class(env, textEncoderClassName, strlen(textEncoderClassName), 761 TextEncoderConstructor, nullptr, 762 sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 763 textEncoderDesc, &textEncoderClass)); 764 765 const char *textDecoderClassName = "TextDecoder"; 766 napi_value textDecoderClass = nullptr; 767 napi_property_descriptor textdecoderDesc[] = { 768 DECLARE_NAPI_FUNCTION("decodeToString", DecodeToString), 769 DECLARE_NAPI_FUNCTION("decode", TextdecoderDecode), 770 DECLARE_NAPI_FUNCTION("decodeWithStream", TextdecoderDecode), 771 }; 772 NAPI_CALL(env, napi_define_class(env, textDecoderClassName, strlen(textDecoderClassName), 773 TextdecoderConstructor, nullptr, 774 sizeof(textdecoderDesc) / sizeof(textdecoderDesc[0]), 775 textdecoderDesc, &textDecoderClass)); 776 napi_property_descriptor desc[] = { 777 DECLARE_NAPI_PROPERTY("TextEncoder", textEncoderClass), 778 DECLARE_NAPI_PROPERTY("TextDecoder", textDecoderClass), 779 }; 780 781 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 782 783 napi_value global = nullptr; 784 NAPI_CALL(env, napi_get_global(env, &global)); 785 NAPI_CALL(env, napi_set_named_property(env, global, "TextDecoderCreate_", textDecoderClass)); 786 787 return exports; 788 } 789 Base64Constructor(napi_env env,napi_callback_info info)790 static napi_value Base64Constructor(napi_env env, napi_callback_info info) 791 { 792 napi_value thisVar = nullptr; 793 void *data = nullptr; 794 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 795 auto objectInfo = new Base64(); 796 napi_status status = napi_wrap(env, thisVar, objectInfo, 797 [](napi_env environment, void *data, void *hint) { 798 auto objInfo = reinterpret_cast<Base64*>(data); 799 if (objInfo != nullptr) { 800 delete objInfo; 801 objInfo = nullptr; 802 } 803 }, nullptr, nullptr); 804 if (status != napi_ok && objectInfo != nullptr) { 805 HILOG_ERROR("Base64Constructor:: napi_wrap failed"); 806 delete objectInfo; 807 objectInfo = nullptr; 808 } 809 return thisVar; 810 } 811 EncodeBase64(napi_env env,napi_callback_info info)812 static napi_value EncodeBase64(napi_env env, napi_callback_info info) 813 { 814 napi_value thisVar = nullptr; 815 size_t requireArgc = 1; 816 size_t argc = 1; 817 napi_value args[1] = { nullptr }; 818 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 819 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 820 napi_typedarray_type valuetype0; 821 size_t length = 0; 822 void *data = nullptr; 823 napi_value arraybuffer = nullptr; 824 size_t byteOffset = 0; 825 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 826 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 827 Base64 *object = nullptr; 828 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 829 napi_value result = object->EncodeSync(env, args[0], Type::BASIC); 830 return result; 831 } 832 EncodeToString(napi_env env,napi_callback_info info)833 static napi_value EncodeToString(napi_env env, napi_callback_info info) 834 { 835 napi_value thisVar = nullptr; 836 size_t requireArgc = 1; 837 size_t argc = 1; 838 napi_value args[1] = { nullptr }; 839 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 840 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 841 napi_typedarray_type valuetype0; 842 size_t length = 0; 843 void *data = nullptr; 844 napi_value arraybuffer = nullptr; 845 size_t byteOffset = 0; 846 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 847 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 848 Base64 *object = nullptr; 849 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 850 napi_value result = object->EncodeToStringSync(env, args[0], Type::BASIC); 851 return result; 852 } 853 DecodeBase64(napi_env env,napi_callback_info info)854 static napi_value DecodeBase64(napi_env env, napi_callback_info info) 855 { 856 napi_value thisVar = nullptr; 857 size_t requireArgc = 1; 858 size_t argc = 1; 859 napi_value args[1] = { nullptr }; 860 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 861 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 862 napi_typedarray_type valuetype0; 863 napi_valuetype valuetype1; 864 size_t length = 0; 865 void *data = nullptr; 866 napi_value arraybuffer = nullptr; 867 size_t byteOffset = 0; 868 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 869 if (valuetype1 != napi_valuetype::napi_string) { 870 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, 871 &data, &arraybuffer, &byteOffset)); 872 } 873 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 874 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 875 return nullptr; 876 } 877 Base64 *object = nullptr; 878 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 879 napi_value result = object->DecodeSync(env, args[0], Type::BASIC); 880 return result; 881 } 882 EncodeAsync(napi_env env,napi_callback_info info)883 static napi_value EncodeAsync(napi_env env, napi_callback_info info) 884 { 885 napi_value thisVar = nullptr; 886 size_t requireArgc = 1; 887 size_t argc = 1; 888 napi_value args[1] = { nullptr }; 889 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 890 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 891 napi_typedarray_type valuetype0; 892 size_t length = 0; 893 void *data = nullptr; 894 napi_value arraybuffer = nullptr; 895 size_t byteOffset = 0; 896 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 897 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 898 Base64 *object = nullptr; 899 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 900 napi_value result = object->Encode(env, args[0], Type::BASIC); 901 return result; 902 } 903 EncodeToStringAsync(napi_env env,napi_callback_info info)904 static napi_value EncodeToStringAsync(napi_env env, napi_callback_info info) 905 { 906 napi_value thisVar = nullptr; 907 size_t requireArgc = 1; 908 size_t argc = 1; 909 napi_value args[1] = { nullptr }; 910 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 911 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 912 napi_typedarray_type valuetype0; 913 size_t length = 0; 914 void *data = nullptr; 915 napi_value arraybuffer = nullptr; 916 size_t byteOffset = 0; 917 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 918 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 919 Base64 *object = nullptr; 920 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 921 napi_value result = object->EncodeToString(env, args[0], Type::BASIC); 922 return result; 923 } DecodeAsync(napi_env env,napi_callback_info info)924 static napi_value DecodeAsync(napi_env env, napi_callback_info info) 925 { 926 napi_value thisVar = nullptr; 927 size_t requireArgc = 1; 928 size_t argc = 1; 929 napi_value args[1] = { nullptr }; 930 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 931 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 932 napi_typedarray_type valuetype0; 933 napi_valuetype valuetype1; 934 size_t length = 0; 935 void *data = nullptr; 936 napi_value arraybuffer = nullptr; 937 size_t byteOffset = 0; 938 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 939 if (valuetype1 != napi_valuetype::napi_string) { 940 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, 941 &length, &data, &arraybuffer, &byteOffset)); 942 } 943 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 944 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 945 return nullptr; 946 } 947 Base64 *object = nullptr; 948 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 949 napi_value result = object->Decode(env, args[0], Type::BASIC); 950 return result; 951 } 952 EncodeToStringHelper(napi_env env,napi_callback_info info)953 static napi_value EncodeToStringHelper(napi_env env, napi_callback_info info) 954 { 955 size_t argc = 2; // 2:The number of parameters is 2 956 napi_value args[2] = { nullptr }; 957 napi_value thisVar = nullptr; 958 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 959 int32_t encode = 0; 960 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 961 Type typeValue = static_cast<Type>(encode); 962 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 963 return ThrowError(env, 964 "Parameter error. The target encoding type option must be one of the Type enumerations."); 965 } 966 Base64 *object = nullptr; 967 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 968 return object->EncodeToStringSync(env, args[0], typeValue); 969 } 970 EncodeBase64Helper(napi_env env,napi_callback_info info)971 static napi_value EncodeBase64Helper(napi_env env, napi_callback_info info) 972 { 973 size_t argc = 2; // 2:The number of parameters is 2 974 napi_value args[2] = { nullptr }; 975 napi_value thisVar = nullptr; 976 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 977 int32_t encode = 0; 978 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 979 Type typeValue = static_cast<Type>(encode); 980 if (typeValue != Type::BASIC && typeValue != Type::BASIC_URL_SAFE) { 981 return ThrowError(env, "Parameter error. The target encoding type option must be BASIC or BASIC_URL_SAFE."); 982 } 983 Base64 *object = nullptr; 984 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 985 return object->EncodeSync(env, args[0], typeValue); 986 } 987 EncodeAsyncHelper(napi_env env,napi_callback_info info)988 static napi_value EncodeAsyncHelper(napi_env env, napi_callback_info info) 989 { 990 size_t argc = 2; // 2:The number of parameters is 2 991 napi_value args[2] = { nullptr }; 992 napi_value thisVar = nullptr; 993 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 994 int32_t encode = 0; 995 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 996 Type typeValue = static_cast<Type>(encode); 997 Base64 *object = nullptr; 998 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 999 return object->Encode(env, args[0], typeValue); 1000 } 1001 EncodeToStringAsyncHelper(napi_env env,napi_callback_info info)1002 static napi_value EncodeToStringAsyncHelper(napi_env env, napi_callback_info info) 1003 { 1004 size_t argc = 2; // 2:The number of parameters is 2 1005 napi_value args[2] = { nullptr }; 1006 napi_value thisVar = nullptr; 1007 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1008 int32_t encode = 0; 1009 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1010 Type typeValue = static_cast<Type>(encode); 1011 Base64 *object = nullptr; 1012 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1013 napi_value result = object->EncodeToString(env, args[0], typeValue); 1014 return result; 1015 } 1016 DecodeBase64Helper(napi_env env,napi_callback_info info)1017 static napi_value DecodeBase64Helper(napi_env env, napi_callback_info info) 1018 { 1019 size_t argc = 2; // 2:The number of parameters is 2 1020 napi_value args[2] = { nullptr }; 1021 napi_value thisVar = nullptr; 1022 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1023 int32_t encode = 0; 1024 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1025 Type typeValue = static_cast<Type>(encode); 1026 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 1027 return ThrowError(env, 1028 "Parameter error. The target encoding type option must be one of the Type enumerations."); 1029 } 1030 Base64 *object = nullptr; 1031 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1032 return object->DecodeSync(env, args[0], typeValue); 1033 } 1034 DecodeAsyncHelper(napi_env env,napi_callback_info info)1035 static napi_value DecodeAsyncHelper(napi_env env, napi_callback_info info) 1036 { 1037 size_t argc = 2; // 2:The number of parameters is 2 1038 napi_value args[2] = { nullptr }; 1039 napi_value thisVar = nullptr; 1040 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1041 int32_t encode = 0; 1042 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1043 Type typeValue = static_cast<Type>(encode); 1044 Base64 *object = nullptr; 1045 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1046 return object->Decode(env, args[0], typeValue); 1047 } 1048 1049 // Types TypesConstructor(napi_env env,napi_callback_info info)1050 static napi_value TypesConstructor(napi_env env, napi_callback_info info) 1051 { 1052 napi_value thisVar = nullptr; 1053 void* data = nullptr; 1054 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 1055 auto objectInfo = new Types(); 1056 napi_status status = napi_wrap(env, thisVar, objectInfo, 1057 [](napi_env environment, void* data, void* hint) { 1058 auto objectInformation = reinterpret_cast<Types*>(data); 1059 if (objectInformation != nullptr) { 1060 delete objectInformation; 1061 objectInformation = nullptr; 1062 } 1063 }, nullptr, nullptr); 1064 if (status != napi_ok && objectInfo != nullptr) { 1065 delete objectInfo; 1066 objectInfo = nullptr; 1067 } 1068 return thisVar; 1069 } 1070 IsAnyArrayBuffer(napi_env env,napi_callback_info info)1071 static napi_value IsAnyArrayBuffer(napi_env env, napi_callback_info info) 1072 { 1073 napi_value thisVar = nullptr; 1074 size_t argc = 1; 1075 napi_value args = nullptr; 1076 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1077 Types* object = nullptr; 1078 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1079 napi_value rst = object->IsAnyArrayBuffer(env, args); 1080 return rst; 1081 } 1082 IsArrayBufferView(napi_env env,napi_callback_info info)1083 static napi_value IsArrayBufferView(napi_env env, napi_callback_info info) 1084 { 1085 napi_value thisVar = nullptr; 1086 size_t argc = 1; 1087 napi_value args = nullptr; 1088 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1089 Types* object = nullptr; 1090 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1091 napi_value rst = object->IsArrayBufferView(env, args); 1092 return rst; 1093 } 1094 IsArgumentsObject(napi_env env,napi_callback_info info)1095 static napi_value IsArgumentsObject(napi_env env, napi_callback_info info) 1096 { 1097 napi_value thisVar = nullptr; 1098 size_t argc = 1; 1099 napi_value args = nullptr; 1100 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1101 Types* object = nullptr; 1102 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1103 napi_value rst = object->IsArgumentsObject(env, args); 1104 return rst; 1105 } 1106 IsArrayBuffer(napi_env env,napi_callback_info info)1107 static napi_value IsArrayBuffer(napi_env env, napi_callback_info info) 1108 { 1109 napi_value thisVar = nullptr; 1110 size_t argc = 1; 1111 napi_value args = nullptr; 1112 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1113 Types* object = nullptr; 1114 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1115 napi_value rst = object->IsArrayBuffer(env, args); 1116 return rst; 1117 } 1118 IsAsyncFunction(napi_env env,napi_callback_info info)1119 static napi_value IsAsyncFunction(napi_env env, napi_callback_info info) 1120 { 1121 napi_value thisVar = nullptr; 1122 size_t argc = 1; 1123 napi_value args = nullptr; 1124 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1125 Types* object = nullptr; 1126 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1127 napi_value rst = object->IsAsyncFunction(env, args); 1128 return rst; 1129 } 1130 IsBigInt64Array(napi_env env,napi_callback_info info)1131 static napi_value IsBigInt64Array(napi_env env, napi_callback_info info) 1132 { 1133 napi_value thisVar = nullptr; 1134 size_t argc = 1; 1135 napi_value args = nullptr; 1136 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1137 Types* object = nullptr; 1138 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1139 napi_value rst = object->IsBigInt64Array(env, args); 1140 return rst; 1141 } 1142 IsBigUint64Array(napi_env env,napi_callback_info info)1143 static napi_value IsBigUint64Array(napi_env env, napi_callback_info info) 1144 { 1145 napi_value thisVar = nullptr; 1146 size_t argc = 1; 1147 napi_value args = nullptr; 1148 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1149 Types* object = nullptr; 1150 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1151 napi_value rst = object->IsBigUint64Array(env, args); 1152 return rst; 1153 } 1154 IsBooleanObject(napi_env env,napi_callback_info info)1155 static napi_value IsBooleanObject(napi_env env, napi_callback_info info) 1156 { 1157 napi_value thisVar = nullptr; 1158 size_t argc = 1; 1159 napi_value args = nullptr; 1160 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1161 Types* object = nullptr; 1162 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1163 napi_value rst = object->IsBooleanObject(env, args); 1164 return rst; 1165 } 1166 IsBoxedPrimitive(napi_env env,napi_callback_info info)1167 static napi_value IsBoxedPrimitive(napi_env env, napi_callback_info info) 1168 { 1169 napi_value thisVar = nullptr; 1170 size_t argc = 1; 1171 napi_value args = nullptr; 1172 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1173 Types* object = nullptr; 1174 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1175 napi_value rst = object->IsBoxedPrimitive(env, args); 1176 return rst; 1177 } 1178 IsDataView(napi_env env,napi_callback_info info)1179 static napi_value IsDataView(napi_env env, napi_callback_info info) 1180 { 1181 napi_value thisVar = nullptr; 1182 size_t argc = 1; 1183 napi_value args = nullptr; 1184 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1185 Types* object = nullptr; 1186 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1187 napi_value rst = object->IsDataView(env, args); 1188 return rst; 1189 } 1190 IsDate(napi_env env,napi_callback_info info)1191 static napi_value IsDate(napi_env env, napi_callback_info info) 1192 { 1193 napi_value thisVar = nullptr; 1194 size_t argc = 1; 1195 napi_value args = nullptr; 1196 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1197 Types* object = nullptr; 1198 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1199 napi_value rst = object->IsDate(env, args); 1200 return rst; 1201 } 1202 IsExternal(napi_env env,napi_callback_info info)1203 static napi_value IsExternal(napi_env env, napi_callback_info info) 1204 { 1205 napi_value thisVar = nullptr; 1206 size_t argc = 1; 1207 napi_value args = nullptr; 1208 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1209 Types* object = nullptr; 1210 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1211 napi_value rst = object->IsExternal(env, args); 1212 return rst; 1213 } 1214 IsFloat32Array(napi_env env,napi_callback_info info)1215 static napi_value IsFloat32Array(napi_env env, napi_callback_info info) 1216 { 1217 napi_value thisVar = nullptr; 1218 size_t argc = 1; 1219 napi_value args = nullptr; 1220 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1221 Types* object = nullptr; 1222 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1223 napi_value rst = object->IsFloat32Array(env, args); 1224 return rst; 1225 } 1226 IsFloat64Array(napi_env env,napi_callback_info info)1227 static napi_value IsFloat64Array(napi_env env, napi_callback_info info) 1228 { 1229 napi_value thisVar = nullptr; 1230 size_t argc = 1; 1231 napi_value args = nullptr; 1232 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1233 Types* object = nullptr; 1234 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1235 napi_value rst = object->IsFloat64Array(env, args); 1236 return rst; 1237 } 1238 IsGeneratorFunction(napi_env env,napi_callback_info info)1239 static napi_value IsGeneratorFunction(napi_env env, napi_callback_info info) 1240 { 1241 napi_value thisVar = nullptr; 1242 size_t argc = 1; 1243 napi_value args = nullptr; 1244 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1245 Types* object = nullptr; 1246 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1247 napi_value rst = object->IsGeneratorFunction(env, args); 1248 return rst; 1249 } 1250 IsGeneratorObject(napi_env env,napi_callback_info info)1251 static napi_value IsGeneratorObject(napi_env env, napi_callback_info info) 1252 { 1253 napi_value thisVar = nullptr; 1254 size_t requireArgc = 1; 1255 size_t argc = 1; 1256 napi_value args = nullptr; 1257 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1258 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1259 Types* object = nullptr; 1260 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1261 napi_value result = object->IsGeneratorObject(env, args); 1262 return result; 1263 } 1264 IsInt8Array(napi_env env,napi_callback_info info)1265 static napi_value IsInt8Array(napi_env env, napi_callback_info info) 1266 { 1267 napi_value thisVar = nullptr; 1268 size_t requireArgc = 1; 1269 size_t argc = 1; 1270 napi_value args = nullptr; 1271 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1272 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1273 Types* object = nullptr; 1274 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1275 napi_value result = object->IsInt8Array(env, args); 1276 return result; 1277 } 1278 IsInt16Array(napi_env env,napi_callback_info info)1279 static napi_value IsInt16Array(napi_env env, napi_callback_info info) 1280 { 1281 napi_value thisVar = nullptr; 1282 size_t requireArgc = 1; 1283 size_t argc = 1; 1284 napi_value args = nullptr; 1285 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1286 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1287 Types* object = nullptr; 1288 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1289 napi_value result = object->IsInt16Array(env, args); 1290 return result; 1291 } 1292 IsInt32Array(napi_env env,napi_callback_info info)1293 static napi_value IsInt32Array(napi_env env, napi_callback_info info) 1294 { 1295 napi_value thisVar = nullptr; 1296 size_t requireArgc = 1; 1297 size_t argc = 1; 1298 napi_value args = nullptr; 1299 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1300 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1301 Types* object = nullptr; 1302 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1303 napi_value result = object->IsInt32Array(env, args); 1304 return result; 1305 } 1306 IsMap(napi_env env,napi_callback_info info)1307 static napi_value IsMap(napi_env env, napi_callback_info info) 1308 { 1309 napi_value thisVar = nullptr; 1310 size_t requireArgc = 1; 1311 size_t argc = 1; 1312 napi_value args = nullptr; 1313 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1314 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1315 Types* object = nullptr; 1316 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1317 napi_value result = object->IsMap(env, args); 1318 return result; 1319 } 1320 IsMapIterator(napi_env env,napi_callback_info info)1321 static napi_value IsMapIterator(napi_env env, napi_callback_info info) 1322 { 1323 napi_value thisVar = nullptr; 1324 size_t requireArgc = 1; 1325 size_t argc = 1; 1326 napi_value args = nullptr; 1327 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1328 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1329 Types* object = nullptr; 1330 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1331 napi_value result = object->IsMapIterator(env, args); 1332 return result; 1333 } 1334 IsModuleNamespaceObject(napi_env env,napi_callback_info info)1335 static napi_value IsModuleNamespaceObject(napi_env env, napi_callback_info info) 1336 { 1337 napi_value thisVar = nullptr; 1338 size_t requireArgc = 1; 1339 size_t argc = 1; 1340 napi_value args = nullptr; 1341 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1342 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1343 Types* object = nullptr; 1344 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1345 napi_value result = object->IsModuleNamespaceObject(env, args); 1346 return result; 1347 } 1348 IsNativeError(napi_env env,napi_callback_info info)1349 static napi_value IsNativeError(napi_env env, napi_callback_info info) 1350 { 1351 napi_value thisVar = nullptr; 1352 size_t requireArgc = 1; 1353 size_t argc = 1; 1354 napi_value args = nullptr; 1355 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1356 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1357 Types* object = nullptr; 1358 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1359 napi_value result = object->IsNativeError(env, args); 1360 return result; 1361 } 1362 IsNumberObject(napi_env env,napi_callback_info info)1363 static napi_value IsNumberObject(napi_env env, napi_callback_info info) 1364 { 1365 napi_value thisVar = nullptr; 1366 size_t requireArgc = 1; 1367 size_t argc = 1; 1368 napi_value args = nullptr; 1369 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1370 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1371 Types* object = nullptr; 1372 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1373 napi_value result = object->IsNumberObject(env, args); 1374 return result; 1375 } 1376 IsPromise(napi_env env,napi_callback_info info)1377 static napi_value IsPromise(napi_env env, napi_callback_info info) 1378 { 1379 napi_value thisVar = nullptr; 1380 size_t requireArgc = 1; 1381 size_t argc = 1; 1382 napi_value args = nullptr; 1383 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1384 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1385 Types* object = nullptr; 1386 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1387 napi_value result = object->IsPromise(env, args); 1388 return result; 1389 } 1390 IsProxy(napi_env env,napi_callback_info info)1391 static napi_value IsProxy(napi_env env, napi_callback_info info) 1392 { 1393 napi_value thisVar = nullptr; 1394 size_t requireArgc = 1; 1395 size_t argc = 1; 1396 napi_value args = nullptr; 1397 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1398 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1399 Types* object = nullptr; 1400 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1401 napi_value result = object->IsProxy(env, args); 1402 return result; 1403 } 1404 IsRegExp(napi_env env,napi_callback_info info)1405 static napi_value IsRegExp(napi_env env, napi_callback_info info) 1406 { 1407 napi_value thisVar = nullptr; 1408 size_t requireArgc = 1; 1409 size_t argc = 1; 1410 napi_value args = nullptr; 1411 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1412 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1413 Types* object = nullptr; 1414 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1415 napi_value result = object->IsRegExp(env, args); 1416 return result; 1417 } 1418 IsSet(napi_env env,napi_callback_info info)1419 static napi_value IsSet(napi_env env, napi_callback_info info) 1420 { 1421 napi_value thisVar = nullptr; 1422 size_t requireArgc = 1; 1423 size_t argc = 1; 1424 napi_value args = nullptr; 1425 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1426 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1427 Types* object = nullptr; 1428 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1429 napi_value result = object->IsSet(env, args); 1430 return result; 1431 } 1432 IsSetIterator(napi_env env,napi_callback_info info)1433 static napi_value IsSetIterator(napi_env env, napi_callback_info info) 1434 { 1435 napi_value thisVar = nullptr; 1436 size_t requireArgc = 1; 1437 size_t argc = 1; 1438 napi_value args = nullptr; 1439 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1440 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1441 Types* object = nullptr; 1442 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1443 napi_value result = object->IsSetIterator(env, args); 1444 return result; 1445 } 1446 IsSharedArrayBuffer(napi_env env,napi_callback_info info)1447 static napi_value IsSharedArrayBuffer(napi_env env, napi_callback_info info) 1448 { 1449 napi_value thisVar = nullptr; 1450 size_t requireArgc = 1; 1451 size_t argc = 1; 1452 napi_value args = nullptr; 1453 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1454 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1455 Types* object = nullptr; 1456 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1457 napi_value result = object->IsSharedArrayBuffer(env, args); 1458 return result; 1459 } 1460 IsStringObject(napi_env env,napi_callback_info info)1461 static napi_value IsStringObject(napi_env env, napi_callback_info info) 1462 { 1463 napi_value thisVar = nullptr; 1464 size_t requireArgc = 1; 1465 size_t argc = 1; 1466 napi_value args = nullptr; 1467 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1468 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1469 Types* object = nullptr; 1470 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1471 napi_value result = object->IsStringObject(env, args); 1472 return result; 1473 } 1474 IsSymbolObject(napi_env env,napi_callback_info info)1475 static napi_value IsSymbolObject(napi_env env, napi_callback_info info) 1476 { 1477 napi_value thisVar = nullptr; 1478 size_t requireArgc = 1; 1479 size_t argc = 1; 1480 napi_value args = nullptr; 1481 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1482 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1483 Types* object = nullptr; 1484 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1485 napi_value result = object->IsSymbolObject(env, args); 1486 return result; 1487 } 1488 IsTypedArray(napi_env env,napi_callback_info info)1489 static napi_value IsTypedArray(napi_env env, napi_callback_info info) 1490 { 1491 napi_value thisVar = nullptr; 1492 size_t requireArgc = 1; 1493 size_t argc = 1; 1494 napi_value args = nullptr; 1495 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1496 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1497 Types* object = nullptr; 1498 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1499 napi_value result = object->IsTypedArray(env, args); 1500 return result; 1501 } 1502 IsUint8Array(napi_env env,napi_callback_info info)1503 static napi_value IsUint8Array(napi_env env, napi_callback_info info) 1504 { 1505 napi_value thisVar = nullptr; 1506 size_t requireArgc = 1; 1507 size_t argc = 1; 1508 napi_value args = nullptr; 1509 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1510 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1511 Types* object = nullptr; 1512 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1513 napi_value result = object->IsUint8Array(env, args); 1514 return result; 1515 } 1516 IsUint8ClampedArray(napi_env env,napi_callback_info info)1517 static napi_value IsUint8ClampedArray(napi_env env, napi_callback_info info) 1518 { 1519 napi_value thisVar = nullptr; 1520 size_t requireArgc = 1; 1521 size_t argc = 1; 1522 napi_value args = nullptr; 1523 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1524 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1525 Types* object = nullptr; 1526 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1527 napi_value result = object->IsUint8ClampedArray(env, args); 1528 return result; 1529 } 1530 IsUint16Array(napi_env env,napi_callback_info info)1531 static napi_value IsUint16Array(napi_env env, napi_callback_info info) 1532 { 1533 napi_value thisVar = nullptr; 1534 size_t requireArgc = 1; 1535 size_t argc = 1; 1536 napi_value args = nullptr; 1537 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1538 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1539 Types* object = nullptr; 1540 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1541 napi_value result = object->IsUint16Array(env, args); 1542 return result; 1543 } 1544 IsUint32Array(napi_env env,napi_callback_info info)1545 static napi_value IsUint32Array(napi_env env, napi_callback_info info) 1546 { 1547 napi_value thisVar = nullptr; 1548 size_t requireArgc = 1; 1549 size_t argc = 1; 1550 napi_value args = nullptr; 1551 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1552 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1553 Types* object = nullptr; 1554 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1555 napi_value result = object->IsUint32Array(env, args); 1556 return result; 1557 } 1558 IsWeakMap(napi_env env,napi_callback_info info)1559 static napi_value IsWeakMap(napi_env env, napi_callback_info info) 1560 { 1561 napi_value thisVar = nullptr; 1562 size_t requireArgc = 1; 1563 size_t argc = 1; 1564 napi_value args = nullptr; 1565 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1566 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1567 Types* object = nullptr; 1568 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1569 napi_value result = object->IsWeakMap(env, args); 1570 return result; 1571 } 1572 IsWeakSet(napi_env env,napi_callback_info info)1573 static napi_value IsWeakSet(napi_env env, napi_callback_info info) 1574 { 1575 napi_value thisVar = nullptr; 1576 size_t requireArgc = 1; 1577 size_t argc = 1; 1578 napi_value args = nullptr; 1579 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1580 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1581 Types* object = nullptr; 1582 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1583 napi_value result = object->IsWeakSet(env, args); 1584 return result; 1585 } 1586 1587 // StringDecoder StringDecoderConstructor(napi_env env,napi_callback_info info)1588 static napi_value StringDecoderConstructor(napi_env env, napi_callback_info info) 1589 { 1590 size_t argc = 1; 1591 napi_value thisVar = nullptr; 1592 napi_value argv = nullptr; 1593 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1594 std::string enconding = "utf-8"; 1595 if (argc == 1) { 1596 napi_valuetype valuetype; 1597 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1598 if (valuetype == napi_string) { 1599 size_t bufferSize = 0; 1600 if (napi_get_value_string_utf8(env, argv, nullptr, 0, &bufferSize) != napi_ok) { 1601 HILOG_ERROR("StringDecoder:: can not get argv size"); 1602 return nullptr; 1603 } 1604 std::string buffer = ""; 1605 buffer.reserve(bufferSize + 1); 1606 buffer.resize(bufferSize); 1607 if (napi_get_value_string_utf8(env, argv, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 1608 HILOG_ERROR("StringDecoder:: can not get argv value"); 1609 return nullptr; 1610 } 1611 if (!CheckEncodingFormat(buffer)) { 1612 napi_throw_error(env, "401", 1613 "Parameter error. Wrong encoding format, the current encoding format is not support."); 1614 return nullptr; 1615 } 1616 enconding = buffer; 1617 } 1618 } 1619 auto objectInfo = new StringDecoder(enconding); 1620 napi_status status = napi_wrap(env, thisVar, objectInfo, 1621 [](napi_env environment, void* data, void* hint) { 1622 auto obj = reinterpret_cast<StringDecoder*>(data); 1623 if (obj != nullptr) { 1624 delete obj; 1625 obj = nullptr; 1626 } 1627 }, nullptr, nullptr); 1628 if (status != napi_ok && objectInfo != nullptr) { 1629 HILOG_ERROR("StringDecoderConstructor:: napi_wrap failed."); 1630 delete objectInfo; 1631 objectInfo = nullptr; 1632 } 1633 return thisVar; 1634 } 1635 Write(napi_env env,napi_callback_info info)1636 static napi_value Write(napi_env env, napi_callback_info info) 1637 { 1638 napi_value thisVar = nullptr; 1639 size_t argc = 1; 1640 napi_value argv = nullptr; 1641 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1642 napi_valuetype valuetype; 1643 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1644 if (valuetype == napi_string) { 1645 return argv; 1646 } 1647 StringDecoder *object = nullptr; 1648 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1649 return object->Write(env, argv); 1650 } 1651 End(napi_env env,napi_callback_info info)1652 static napi_value End(napi_env env, napi_callback_info info) 1653 { 1654 napi_value thisVar = nullptr; 1655 size_t argc = 1; 1656 napi_value argv = nullptr; 1657 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1658 StringDecoder *object = nullptr; 1659 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1660 if (argc == 0) { 1661 return object->End(env); 1662 } 1663 napi_valuetype valuetype; 1664 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1665 if (valuetype == napi_string) { 1666 return argv; 1667 } 1668 if (valuetype == napi_undefined) { 1669 return object->End(env); 1670 } 1671 return object->End(env, argv); 1672 } 1673 TypeofInit(napi_env env,napi_value exports)1674 static napi_value TypeofInit(napi_env env, napi_value exports) 1675 { 1676 const char* typeofClassName = "Types"; 1677 napi_value typeofClass = nullptr; 1678 napi_property_descriptor typeofDesc[] = { 1679 DECLARE_NAPI_FUNCTION("isBigInt64Array", IsBigInt64Array), 1680 DECLARE_NAPI_FUNCTION("isBigUint64Array", IsBigUint64Array), 1681 DECLARE_NAPI_FUNCTION("isBooleanObject", IsBooleanObject), 1682 DECLARE_NAPI_FUNCTION("isBoxedPrimitive", IsBoxedPrimitive), 1683 DECLARE_NAPI_FUNCTION("isAnyArrayBuffer", IsAnyArrayBuffer), 1684 DECLARE_NAPI_FUNCTION("isArrayBufferView", IsArrayBufferView), 1685 DECLARE_NAPI_FUNCTION("isArgumentsObject", IsArgumentsObject), 1686 DECLARE_NAPI_FUNCTION("isArrayBuffer", IsArrayBuffer), 1687 DECLARE_NAPI_FUNCTION("isDataView", IsDataView), 1688 DECLARE_NAPI_FUNCTION("isDate", IsDate), 1689 DECLARE_NAPI_FUNCTION("isExternal", IsExternal), 1690 DECLARE_NAPI_FUNCTION("isFloat32Array", IsFloat32Array), 1691 DECLARE_NAPI_FUNCTION("isFloat64Array", IsFloat64Array), 1692 DECLARE_NAPI_FUNCTION("isGeneratorFunction", IsGeneratorFunction), 1693 DECLARE_NAPI_FUNCTION("isGeneratorObject", IsGeneratorObject), 1694 DECLARE_NAPI_FUNCTION("isInt8Array", IsInt8Array), 1695 DECLARE_NAPI_FUNCTION("isInt16Array", IsInt16Array), 1696 DECLARE_NAPI_FUNCTION("isInt32Array", IsInt32Array), 1697 DECLARE_NAPI_FUNCTION("isMap", IsMap), 1698 DECLARE_NAPI_FUNCTION("isMapIterator", IsMapIterator), 1699 DECLARE_NAPI_FUNCTION("isModuleNamespaceObject", IsModuleNamespaceObject), 1700 DECLARE_NAPI_FUNCTION("isNativeError", IsNativeError), 1701 DECLARE_NAPI_FUNCTION("isNumberObject", IsNumberObject), 1702 DECLARE_NAPI_FUNCTION("isPromise", IsPromise), 1703 DECLARE_NAPI_FUNCTION("isProxy", IsProxy), 1704 DECLARE_NAPI_FUNCTION("isRegExp", IsRegExp), 1705 DECLARE_NAPI_FUNCTION("isSet", IsSet), 1706 DECLARE_NAPI_FUNCTION("isSetIterator", IsSetIterator), 1707 DECLARE_NAPI_FUNCTION("isSharedArrayBuffer", IsSharedArrayBuffer), 1708 DECLARE_NAPI_FUNCTION("isStringObject", IsStringObject), 1709 DECLARE_NAPI_FUNCTION("isSymbolObject", IsSymbolObject), 1710 DECLARE_NAPI_FUNCTION("isTypedArray", IsTypedArray), 1711 DECLARE_NAPI_FUNCTION("isUint8Array", IsUint8Array), 1712 DECLARE_NAPI_FUNCTION("isUint8ClampedArray", IsUint8ClampedArray), 1713 DECLARE_NAPI_FUNCTION("isUint16Array", IsUint16Array), 1714 DECLARE_NAPI_FUNCTION("isUint32Array", IsUint32Array), 1715 DECLARE_NAPI_FUNCTION("isWeakMap", IsWeakMap), 1716 DECLARE_NAPI_FUNCTION("isWeakSet", IsWeakSet), 1717 DECLARE_NAPI_FUNCTION("isAsyncFunction", IsAsyncFunction), 1718 }; 1719 NAPI_CALL(env, napi_define_class(env, typeofClassName, strlen(typeofClassName), TypesConstructor, 1720 nullptr, sizeof(typeofDesc) / sizeof(typeofDesc[0]), typeofDesc, 1721 &typeofClass)); 1722 napi_property_descriptor desc[] = { DECLARE_NAPI_PROPERTY("Types", typeofClass) }; 1723 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1724 return exports; 1725 } 1726 Base64Init(napi_env env,napi_value exports)1727 static napi_value Base64Init(napi_env env, napi_value exports) 1728 { 1729 const char *base64ClassName = "Base64"; 1730 napi_value base64Class = nullptr; 1731 napi_property_descriptor base64Desc[] = { 1732 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64), 1733 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToString), 1734 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64), 1735 DECLARE_NAPI_FUNCTION("encode", EncodeAsync), 1736 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsync), 1737 DECLARE_NAPI_FUNCTION("decode", DecodeAsync), 1738 }; 1739 NAPI_CALL(env, napi_define_class(env, base64ClassName, strlen(base64ClassName), Base64Constructor, 1740 nullptr, sizeof(base64Desc) / sizeof(base64Desc[0]), base64Desc, 1741 &base64Class)); 1742 napi_property_descriptor desc[] = { 1743 DECLARE_NAPI_PROPERTY("Base64", base64Class) 1744 }; 1745 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1746 return exports; 1747 } 1748 Base64HelperInit(napi_env env,napi_value exports)1749 static napi_value Base64HelperInit(napi_env env, napi_value exports) 1750 { 1751 const char *base64HelperClassName = "Base64Helper"; 1752 napi_value Base64HelperClass = nullptr; 1753 napi_property_descriptor Base64HelperDesc[] = { 1754 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64Helper), 1755 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToStringHelper), 1756 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64Helper), 1757 DECLARE_NAPI_FUNCTION("encode", EncodeAsyncHelper), 1758 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsyncHelper), 1759 DECLARE_NAPI_FUNCTION("decode", DecodeAsyncHelper), 1760 }; 1761 NAPI_CALL(env, napi_define_class(env, base64HelperClassName, strlen(base64HelperClassName), Base64Constructor, 1762 nullptr, sizeof(Base64HelperDesc) / sizeof(Base64HelperDesc[0]), 1763 Base64HelperDesc, &Base64HelperClass)); 1764 napi_property_descriptor desc[] = { 1765 DECLARE_NAPI_PROPERTY("Base64Helper", Base64HelperClass) 1766 }; 1767 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1768 return exports; 1769 } 1770 StringDecoderInit(napi_env env,napi_value exports)1771 static napi_value StringDecoderInit(napi_env env, napi_value exports) 1772 { 1773 const char *stringDecoderClassName = "StringDecoder"; 1774 napi_value StringDecoderClass = nullptr; 1775 napi_property_descriptor StringDecoderDesc[] = { 1776 DECLARE_NAPI_FUNCTION("write", Write), 1777 DECLARE_NAPI_FUNCTION("end", End), 1778 }; 1779 NAPI_CALL(env, napi_define_class(env, stringDecoderClassName, strlen(stringDecoderClassName), 1780 StringDecoderConstructor, nullptr, 1781 sizeof(StringDecoderDesc) / sizeof(StringDecoderDesc[0]), 1782 StringDecoderDesc, &StringDecoderClass)); 1783 napi_property_descriptor desc[] = { 1784 DECLARE_NAPI_PROPERTY("StringDecoder", StringDecoderClass) 1785 }; 1786 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1787 return exports; 1788 } 1789 UtilInit(napi_env env,napi_value exports)1790 static napi_value UtilInit(napi_env env, napi_value exports) 1791 { 1792 napi_property_descriptor desc[] = { 1793 DECLARE_NAPI_FUNCTION("printf", Printf), 1794 DECLARE_NAPI_FUNCTION("format", Printf), 1795 DECLARE_NAPI_FUNCTION("geterrorstring", GetErrorString), 1796 DECLARE_NAPI_FUNCTION("errnoToString", GetErrorString), 1797 DECLARE_NAPI_FUNCTION("dealwithformatstring", DealWithFormatString), 1798 DECLARE_NAPI_FUNCTION("randomUUID", RandomUUID), 1799 DECLARE_NAPI_FUNCTION("randomBinaryUUID", RandomBinaryUUID), 1800 DECLARE_NAPI_FUNCTION("parseUUID", ParseUUID), 1801 DECLARE_NAPI_FUNCTION("getHash", GetHash), 1802 DECLARE_NAPI_FUNCTION("getMainThreadStackTrace", GetMainThreadStackTrace) 1803 }; 1804 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1805 TextcoderInit(env, exports); 1806 Base64Init(env, exports); 1807 Base64HelperInit(env, exports); 1808 TypeofInit(env, exports); 1809 StringDecoderInit(env, exports); 1810 return exports; 1811 } 1812 1813 // util JS register 1814 extern "C" NAPI_util_GetJSCode(const char ** buf,int * buflen)1815 __attribute__((visibility("default"))) void NAPI_util_GetJSCode(const char **buf, int *buflen) 1816 { 1817 if (buf != nullptr) { 1818 *buf = _binary_util_js_js_start; 1819 } 1820 if (buflen != nullptr) { 1821 *buflen = _binary_util_js_js_end - _binary_util_js_js_start; 1822 } 1823 } 1824 extern "C" NAPI_util_GetABCCode(const char ** buf,int * buflen)1825 __attribute__((visibility("default"))) void NAPI_util_GetABCCode(const char** buf, int* buflen) 1826 { 1827 if (buf != nullptr) { 1828 *buf = _binary_util_abc_start; 1829 } 1830 if (buflen != nullptr) { 1831 *buflen = _binary_util_abc_end - _binary_util_abc_start; 1832 } 1833 } 1834 1835 // util module define 1836 static napi_module_with_js utilModule = { 1837 .nm_version = 1, 1838 .nm_flags = 0, 1839 .nm_filename = nullptr, 1840 .nm_register_func = UtilInit, 1841 .nm_modname = "util", 1842 .nm_priv = ((void*)0), 1843 .nm_get_abc_code = NAPI_util_GetABCCode, 1844 .nm_get_js_code = NAPI_util_GetJSCode, 1845 }; 1846 // util module register 1847 extern "C" UtilRegisterModule()1848 __attribute__((constructor)) void UtilRegisterModule() 1849 { 1850 napi_module_with_js_register(&utilModule); 1851 UtilPluginJniRegister(); 1852 } 1853 } 1854