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); 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); 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 TextdecoderConstructor(napi_env env,napi_callback_info info)347 static napi_value TextdecoderConstructor(napi_env env, napi_callback_info info) 348 { 349 size_t tempArgc = 0; 350 napi_value thisVar = nullptr; 351 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 352 size_t argc = 0; 353 void *data = nullptr; 354 char *type = nullptr; 355 size_t typeLen = 0; 356 int32_t flags = 0; 357 std::vector<int> paraVec(2, 0); // 2: Specifies the size of the container to be applied for. 358 if (tempArgc == 1) { 359 argc = 1; 360 napi_value argv = nullptr; 361 napi_get_cb_info(env, info, &argc, &argv, nullptr, &data); 362 napi_get_value_string_utf8(env, argv, nullptr, 0, &typeLen); 363 if (typeLen > 0) { 364 type = ApplyMemory(typeLen); 365 } 366 napi_get_value_string_utf8(env, argv, type, typeLen + 1, &typeLen); 367 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 368 argc = 2; // 2: The number of parameters is 2. 369 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 370 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &data); 371 // first para 372 napi_get_value_string_utf8(env, argvArr[0], nullptr, 0, &typeLen); 373 if (typeLen > 0) { 374 type = ApplyMemory(typeLen); 375 } 376 napi_get_value_string_utf8(env, argvArr[0], type, typeLen + 1, &typeLen); 377 napi_get_value_int32(env, argvArr[1], &flags); 378 } 379 std::string enconding = "utf-8"; 380 if (type != nullptr) { 381 enconding = type; 382 } 383 delete []type; 384 type = nullptr; 385 auto objectInfo = new (std::nothrow) TextDecoder(enconding, flags); 386 if (objectInfo == nullptr) { 387 HILOG_ERROR("TextDecoder:: memory allocation failed, objectInfo is nullptr"); 388 return nullptr; 389 } 390 NAPI_CALL(env, napi_wrap( 391 env, thisVar, objectInfo, 392 [](napi_env environment, void *data, void *hint) { 393 auto objInfo = reinterpret_cast<TextDecoder*>(data); 394 if (objInfo != nullptr) { 395 delete objInfo; 396 objInfo = nullptr; 397 } 398 }, 399 nullptr, nullptr)); 400 return thisVar; 401 } 402 DecodeToString(napi_env env,napi_callback_info info)403 static napi_value DecodeToString(napi_env env, napi_callback_info info) 404 { 405 size_t tempArgc = 2; // 2:The number of parameters is 2 406 napi_value thisVar = nullptr; 407 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 408 size_t argc = 0; 409 void *dataPara = nullptr; 410 napi_typedarray_type type; 411 size_t length = 0; 412 void *data = nullptr; 413 napi_value arraybuffer = nullptr; 414 size_t byteOffset = 0; 415 bool iStream = false; 416 TextDecoder *textDecoder = nullptr; 417 napi_unwrap(env, thisVar, (void**)&textDecoder); 418 if (textDecoder == nullptr) { 419 HILOG_ERROR("DecodeToString:: textDecoder is nullptr"); 420 return nullptr; 421 } 422 napi_value valStr = nullptr; 423 if (tempArgc == 1) { 424 argc = 1; 425 napi_value argv = nullptr; 426 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 427 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 428 if (type != napi_uint8_array) { 429 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 430 } 431 valStr = textDecoder->DecodeToString(env, argv, iStream); 432 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 433 argc = 2; // 2: The number of parameters is 2. 434 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 435 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 436 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 437 if (type != napi_uint8_array) { 438 return ThrowError(env, "Parameter error. The type of first Parameter must be Uint8Array."); 439 } 440 napi_valuetype valueType; 441 napi_typeof(env, argvArr[1], &valueType); 442 if (valueType != napi_undefined && valueType != napi_null) { 443 if (valueType != napi_object) { 444 return ThrowError(env, "Parameter error. The type of second Parameter must be object."); 445 } 446 const char *messageKeyStrStream = "stream"; 447 napi_value resultStream = nullptr; 448 napi_get_named_property(env, argvArr[1], messageKeyStrStream, &resultStream); 449 napi_get_value_bool(env, resultStream, &iStream); 450 } 451 valStr = textDecoder->DecodeToString(env, argvArr[0], iStream); 452 } 453 return valStr; 454 } 455 TextdecoderDecode(napi_env env,napi_callback_info info)456 static napi_value TextdecoderDecode(napi_env env, napi_callback_info info) 457 { 458 size_t tempArgc = 2; // 2:The number of parameters is 2 459 napi_value thisVar = nullptr; 460 napi_get_cb_info(env, info, &tempArgc, nullptr, &thisVar, nullptr); 461 size_t argc = 0; 462 void *dataPara = nullptr; 463 napi_typedarray_type type; 464 size_t length = 0; 465 void *data = nullptr; 466 napi_value arraybuffer = nullptr; 467 size_t byteOffset = 0; 468 bool iStream = false; 469 TextDecoder *textDecoder = nullptr; 470 napi_unwrap(env, thisVar, (void**)&textDecoder); 471 if (textDecoder == nullptr) { 472 return nullptr; 473 } 474 napi_value valStr = nullptr; 475 if (tempArgc == 1) { 476 argc = 1; 477 napi_value argv = nullptr; 478 napi_get_cb_info(env, info, &argc, &argv, nullptr, &dataPara); 479 // first para 480 napi_get_typedarray_info(env, argv, &type, &length, &data, &arraybuffer, &byteOffset); 481 if (type != napi_uint8_array) { 482 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 483 } 484 valStr = textDecoder->Decode(env, argv, iStream); 485 } else if (tempArgc == 2) { // 2: The number of parameters is 2. 486 argc = 2; // 2: The number of parameters is 2. 487 napi_value argvArr[2] = { 0 }; // 2:The number of parameters is 2 488 napi_get_cb_info(env, info, &argc, argvArr, nullptr, &dataPara); 489 // first para 490 napi_get_typedarray_info(env, argvArr[0], &type, &length, &data, &arraybuffer, &byteOffset); 491 // second para 492 if (type != napi_uint8_array) { 493 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 494 } 495 napi_valuetype valueType1; 496 napi_typeof(env, argvArr[1], &valueType1); 497 if (valueType1 != napi_undefined && valueType1 != napi_null) { 498 if (valueType1 != napi_object) { 499 return ThrowError(env, "Parameter error. The type of Parameter must be object."); 500 } 501 napi_value messageKeyStream = nullptr; 502 const char *messageKeyStrStream = "stream"; 503 504 napi_value resultStream = nullptr; 505 NAPI_CALL(env, napi_create_string_utf8(env, messageKeyStrStream, strlen(messageKeyStrStream), 506 &messageKeyStream)); 507 NAPI_CALL(env, napi_get_property(env, argvArr[1], messageKeyStream, &resultStream)); 508 NAPI_CALL(env, napi_get_value_bool(env, resultStream, &iStream)); 509 } 510 valStr = textDecoder->Decode(env, argvArr[0], iStream); 511 } 512 return valStr; 513 } 514 CheckEncodingFormat(const std::string & encoding)515 static bool CheckEncodingFormat(const std::string &encoding) 516 { 517 for (const auto& format : conventFormat) { 518 if (format == encoding) { 519 return true; 520 } 521 } 522 return false; 523 } 524 InitTextEncoder(napi_env env,napi_value thisVar,std::string encoding,std::string orgEncoding)525 static napi_value InitTextEncoder(napi_env env, napi_value thisVar, std::string encoding, std::string orgEncoding) 526 { 527 auto object = new (std::nothrow) TextEncoder(encoding); 528 if (object == nullptr) { 529 HILOG_ERROR("TextEncoder:: memory allocation failed, object is nullptr"); 530 return nullptr; 531 } 532 object->SetOrgEncoding(orgEncoding); 533 napi_status status = napi_wrap(env, thisVar, object, 534 [](napi_env environment, void *data, void *hint) { 535 auto obj = reinterpret_cast<TextEncoder*>(data); 536 if (obj != nullptr) { 537 delete obj; 538 obj = nullptr; 539 } 540 }, nullptr, nullptr); 541 if (status != napi_ok) { 542 delete object; 543 object = nullptr; 544 } 545 return thisVar; 546 } 547 548 // Encoder TextEncoderConstructor(napi_env env,napi_callback_info info)549 static napi_value TextEncoderConstructor(napi_env env, napi_callback_info info) 550 { 551 size_t argc = 0; 552 napi_value thisVar = nullptr; 553 napi_value src = nullptr; 554 napi_get_cb_info(env, info, &argc, &src, &thisVar, nullptr); 555 std::string encoding = "utf-8"; 556 std::string orgEncoding = encoding; 557 if (argc == 1) { 558 napi_get_cb_info(env, info, &argc, &src, nullptr, nullptr); 559 napi_valuetype valuetype; 560 napi_typeof(env, src, &valuetype); 561 if (valuetype != napi_undefined && valuetype != napi_null) { 562 if (valuetype != napi_string) { 563 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 564 } 565 size_t bufferSize = 0; 566 if (napi_get_value_string_utf8(env, src, nullptr, 0, &bufferSize) != napi_ok) { 567 HILOG_ERROR("TextEncoder:: can not get src size"); 568 return nullptr; 569 } 570 std::string buffer(bufferSize, '\0'); 571 if (napi_get_value_string_utf8(env, src, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 572 HILOG_ERROR("TextEncoder:: can not get src value"); 573 return nullptr; 574 } 575 orgEncoding = buffer; 576 for (char &temp : buffer) { 577 temp = std::tolower(static_cast<unsigned char>(temp)); 578 } 579 NAPI_ASSERT(env, CheckEncodingFormat(buffer), 580 "Wrong encoding format, the current encoding format is not support"); 581 encoding = buffer; 582 } 583 } 584 return InitTextEncoder(env, thisVar, encoding, orgEncoding); 585 } 586 GetEncoding(napi_env env,napi_callback_info info)587 static napi_value GetEncoding(napi_env env, napi_callback_info info) 588 { 589 napi_value thisVar = nullptr; 590 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); 591 592 TextEncoder *object = nullptr; 593 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 594 595 return object->GetEncoding(env); 596 } 597 Encode(napi_env env,napi_callback_info info)598 static napi_value Encode(napi_env env, napi_callback_info info) 599 { 600 napi_value thisVar = nullptr; 601 size_t requireArgc = 1; 602 size_t argc = 1; 603 napi_value args = nullptr; 604 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 605 NAPI_ASSERT(env, argc <= requireArgc, "Wrong number of arguments"); 606 607 napi_value result; 608 if (argc == 1) { 609 napi_valuetype valuetype; 610 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 611 if (!IsValidValue(env, args)) { 612 napi_get_undefined(env, &result); 613 return result; 614 } 615 NAPI_ASSERT(env, valuetype == napi_string, "Wrong argument type. String expected."); 616 } else { 617 napi_get_undefined(env, &result); 618 return result; 619 } 620 TextEncoder *object = nullptr; 621 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 622 623 result = object->Encode(env, args); 624 625 return result; 626 } 627 EncodeIntoOne(napi_env env,napi_callback_info info)628 static napi_value EncodeIntoOne(napi_env env, napi_callback_info info) 629 { 630 napi_value thisVar = nullptr; 631 // EncodeIntoOne is invoked by EncodeIntoArgs, argc can be 0 or 1 632 // if argc is 0, typeof args is undefined. 633 size_t argc = 1; 634 napi_value args = nullptr; 635 napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr); 636 napi_value result = nullptr; 637 napi_valuetype valuetype; 638 NAPI_CALL(env, napi_typeof(env, args, &valuetype)); 639 640 if (valuetype == napi_null || valuetype == napi_undefined) { 641 napi_get_undefined(env, &result); 642 return result; 643 } 644 if (valuetype != napi_string) { 645 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 646 } 647 648 TextEncoder *object = nullptr; 649 NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&object)); 650 result = object->Encode(env, args); 651 return result; 652 } 653 EncodeIntoTwo(napi_env env,napi_callback_info info)654 static napi_value EncodeIntoTwo(napi_env env, napi_callback_info info) 655 { 656 napi_value thisVar = nullptr; 657 size_t requireArgc = 2; // 2:The number of parameters is 2 658 size_t argc = 2; // 2:The number of parameters is 2 659 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 660 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 661 662 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 663 664 napi_valuetype valuetype0; 665 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 666 667 napi_typedarray_type valuetype1; 668 size_t length = 0; 669 void *data = nullptr; 670 napi_value arraybuffer = nullptr; 671 size_t byteOffset = 0; 672 NAPI_CALL(env, napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset)); 673 674 NAPI_ASSERT(env, valuetype0 == napi_string, "Wrong argument type. String expected."); 675 NAPI_ASSERT(env, valuetype1 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 676 677 TextEncoder *object = nullptr; 678 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 679 680 napi_value result = object->EncodeInto(env, args[0], args[1]); 681 682 return result; 683 } 684 EncodeIntoUint8Array(napi_env env,napi_callback_info info)685 static napi_value EncodeIntoUint8Array(napi_env env, napi_callback_info info) 686 { 687 napi_value thisVar = nullptr; 688 size_t argc = 2; // 2:The number of parameters is 2 689 napi_value args[2] = { nullptr }; // 2:The number of parameters is 2 690 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 691 napi_valuetype valuetype0; 692 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); 693 napi_typedarray_type valuetype1; 694 size_t length = 0; 695 void *data = nullptr; 696 napi_value arraybuffer = nullptr; 697 size_t byteOffset = 0; 698 napi_get_typedarray_info(env, args[1], &valuetype1, &length, &data, &arraybuffer, &byteOffset); 699 if (valuetype0 != napi_string) { 700 return ThrowError(env, "Parameter error. The type of Parameter must be string."); 701 } 702 if (valuetype1 != napi_uint8_array) { 703 return ThrowError(env, "Parameter error. The type of Parameter must be Uint8Array."); 704 } 705 TextEncoder *object = nullptr; 706 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 707 napi_value result = object->EncodeInto(env, args[0], args[1]); 708 return result; 709 } 710 EncodeIntoArgs(napi_env env,napi_callback_info info)711 static napi_value EncodeIntoArgs(napi_env env, napi_callback_info info) 712 { 713 size_t argc = 0; 714 napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); 715 if (argc >= 2) { // 2:The number of parameters is 2 716 return EncodeIntoTwo(env, info); 717 } 718 return EncodeIntoOne(env, info); 719 } 720 Create(napi_env env,napi_callback_info info)721 static napi_value Create(napi_env env, napi_callback_info info) 722 { 723 napi_value textEncoderObj = TextEncoderConstructor(env, info); 724 napi_property_descriptor textEncoderDesc[] = { 725 DECLARE_NAPI_GETTER("encoding", GetEncoding), 726 DECLARE_NAPI_FUNCTION("encode", Encode), 727 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 728 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 729 }; 730 napi_define_properties(env, textEncoderObj, sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 731 textEncoderDesc); 732 return textEncoderObj; 733 } 734 TextcoderInit(napi_env env,napi_value exports)735 static napi_value TextcoderInit(napi_env env, napi_value exports) 736 { 737 const char *textEncoderClassName = "TextEncoder"; 738 napi_value textEncoderClass = nullptr; 739 napi_property_descriptor textEncoderDesc[] = { 740 DECLARE_NAPI_GETTER("encoding", GetEncoding), 741 DECLARE_NAPI_FUNCTION("encode", Encode), 742 DECLARE_NAPI_FUNCTION("encodeInto", EncodeIntoArgs), 743 DECLARE_NAPI_FUNCTION("encodeIntoUint8Array", EncodeIntoUint8Array), 744 DECLARE_NAPI_STATIC_FUNCTION("create", Create), 745 746 }; 747 NAPI_CALL(env, napi_define_class(env, textEncoderClassName, strlen(textEncoderClassName), 748 TextEncoderConstructor, nullptr, 749 sizeof(textEncoderDesc) / sizeof(textEncoderDesc[0]), 750 textEncoderDesc, &textEncoderClass)); 751 752 const char *textDecoderClassName = "TextDecoder"; 753 napi_value textDecoderClass = nullptr; 754 napi_property_descriptor textdecoderDesc[] = { 755 DECLARE_NAPI_FUNCTION("decodeToString", DecodeToString), 756 DECLARE_NAPI_FUNCTION("decode", TextdecoderDecode), 757 DECLARE_NAPI_FUNCTION("decodeWithStream", TextdecoderDecode), 758 }; 759 NAPI_CALL(env, napi_define_class(env, textDecoderClassName, strlen(textDecoderClassName), 760 TextdecoderConstructor, nullptr, 761 sizeof(textdecoderDesc) / sizeof(textdecoderDesc[0]), 762 textdecoderDesc, &textDecoderClass)); 763 napi_property_descriptor desc[] = { 764 DECLARE_NAPI_PROPERTY("TextEncoder", textEncoderClass), 765 DECLARE_NAPI_PROPERTY("TextDecoder", textDecoderClass), 766 }; 767 768 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 769 770 napi_value global = nullptr; 771 NAPI_CALL(env, napi_get_global(env, &global)); 772 NAPI_CALL(env, napi_set_named_property(env, global, "TextDecoderCreate_", textDecoderClass)); 773 774 return exports; 775 } 776 Base64Constructor(napi_env env,napi_callback_info info)777 static napi_value Base64Constructor(napi_env env, napi_callback_info info) 778 { 779 napi_value thisVar = nullptr; 780 void *data = nullptr; 781 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 782 auto objectInfo = new Base64(); 783 napi_status status = napi_wrap(env, thisVar, objectInfo, 784 [](napi_env environment, void *data, void *hint) { 785 auto objInfo = reinterpret_cast<Base64*>(data); 786 if (objInfo != nullptr) { 787 delete objInfo; 788 objInfo = nullptr; 789 } 790 }, nullptr, nullptr); 791 if (status != napi_ok && objectInfo != nullptr) { 792 HILOG_ERROR("Base64Constructor:: napi_wrap failed"); 793 delete objectInfo; 794 objectInfo = nullptr; 795 } 796 return thisVar; 797 } 798 EncodeBase64(napi_env env,napi_callback_info info)799 static napi_value EncodeBase64(napi_env env, napi_callback_info info) 800 { 801 napi_value thisVar = nullptr; 802 size_t requireArgc = 1; 803 size_t argc = 1; 804 napi_value args[1] = { nullptr }; 805 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 806 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 807 napi_typedarray_type valuetype0; 808 size_t length = 0; 809 void *data = nullptr; 810 napi_value arraybuffer = nullptr; 811 size_t byteOffset = 0; 812 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 813 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 814 Base64 *object = nullptr; 815 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 816 napi_value result = object->EncodeSync(env, args[0], Type::BASIC); 817 return result; 818 } 819 EncodeToString(napi_env env,napi_callback_info info)820 static napi_value EncodeToString(napi_env env, napi_callback_info info) 821 { 822 napi_value thisVar = nullptr; 823 size_t requireArgc = 1; 824 size_t argc = 1; 825 napi_value args[1] = { nullptr }; 826 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 827 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 828 napi_typedarray_type valuetype0; 829 size_t length = 0; 830 void *data = nullptr; 831 napi_value arraybuffer = nullptr; 832 size_t byteOffset = 0; 833 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 834 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 835 Base64 *object = nullptr; 836 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 837 napi_value result = object->EncodeToStringSync(env, args[0], Type::BASIC); 838 return result; 839 } 840 DecodeBase64(napi_env env,napi_callback_info info)841 static napi_value DecodeBase64(napi_env env, napi_callback_info info) 842 { 843 napi_value thisVar = nullptr; 844 size_t requireArgc = 1; 845 size_t argc = 1; 846 napi_value args[1] = { nullptr }; 847 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 848 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 849 napi_typedarray_type valuetype0; 850 napi_valuetype valuetype1; 851 size_t length = 0; 852 void *data = nullptr; 853 napi_value arraybuffer = nullptr; 854 size_t byteOffset = 0; 855 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 856 if (valuetype1 != napi_valuetype::napi_string) { 857 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, 858 &data, &arraybuffer, &byteOffset)); 859 } 860 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 861 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 862 return nullptr; 863 } 864 Base64 *object = nullptr; 865 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 866 napi_value result = object->DecodeSync(env, args[0], Type::BASIC); 867 return result; 868 } 869 EncodeAsync(napi_env env,napi_callback_info info)870 static napi_value EncodeAsync(napi_env env, napi_callback_info info) 871 { 872 napi_value thisVar = nullptr; 873 size_t requireArgc = 1; 874 size_t argc = 1; 875 napi_value args[1] = { nullptr }; 876 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 877 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 878 napi_typedarray_type valuetype0; 879 size_t length = 0; 880 void *data = nullptr; 881 napi_value arraybuffer = nullptr; 882 size_t byteOffset = 0; 883 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 884 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 885 Base64 *object = nullptr; 886 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 887 napi_value result = object->Encode(env, args[0], Type::BASIC); 888 return result; 889 } 890 EncodeToStringAsync(napi_env env,napi_callback_info info)891 static napi_value EncodeToStringAsync(napi_env env, napi_callback_info info) 892 { 893 napi_value thisVar = nullptr; 894 size_t requireArgc = 1; 895 size_t argc = 1; 896 napi_value args[1] = { nullptr }; 897 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 898 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 899 napi_typedarray_type valuetype0; 900 size_t length = 0; 901 void *data = nullptr; 902 napi_value arraybuffer = nullptr; 903 size_t byteOffset = 0; 904 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, &length, &data, &arraybuffer, &byteOffset)); 905 NAPI_ASSERT(env, valuetype0 == napi_uint8_array, "Wrong argument type. napi_uint8_array expected."); 906 Base64 *object = nullptr; 907 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 908 napi_value result = object->EncodeToString(env, args[0], Type::BASIC); 909 return result; 910 } DecodeAsync(napi_env env,napi_callback_info info)911 static napi_value DecodeAsync(napi_env env, napi_callback_info info) 912 { 913 napi_value thisVar = nullptr; 914 size_t requireArgc = 1; 915 size_t argc = 1; 916 napi_value args[1] = { nullptr }; 917 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 918 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 919 napi_typedarray_type valuetype0; 920 napi_valuetype valuetype1; 921 size_t length = 0; 922 void *data = nullptr; 923 napi_value arraybuffer = nullptr; 924 size_t byteOffset = 0; 925 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype1)); 926 if (valuetype1 != napi_valuetype::napi_string) { 927 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &valuetype0, 928 &length, &data, &arraybuffer, &byteOffset)); 929 } 930 if ((valuetype1 != napi_valuetype::napi_string) && (valuetype0 != napi_typedarray_type::napi_uint8_array)) { 931 napi_throw_error(env, nullptr, "The parameter type is incorrect"); 932 return nullptr; 933 } 934 Base64 *object = nullptr; 935 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 936 napi_value result = object->Decode(env, args[0], Type::BASIC); 937 return result; 938 } 939 EncodeToStringHelper(napi_env env,napi_callback_info info)940 static napi_value EncodeToStringHelper(napi_env env, napi_callback_info info) 941 { 942 size_t argc = 2; // 2:The number of parameters is 2 943 napi_value args[2] = { nullptr }; 944 napi_value thisVar = nullptr; 945 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 946 int32_t encode = 0; 947 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 948 Type typeValue = static_cast<Type>(encode); 949 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 950 return ThrowError(env, 951 "Parameter error. The target encoding type option must be one of the Type enumerations."); 952 } 953 Base64 *object = nullptr; 954 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 955 return object->EncodeToStringSync(env, args[0], typeValue); 956 } 957 EncodeBase64Helper(napi_env env,napi_callback_info info)958 static napi_value EncodeBase64Helper(napi_env env, napi_callback_info info) 959 { 960 size_t argc = 2; // 2:The number of parameters is 2 961 napi_value args[2] = { nullptr }; 962 napi_value thisVar = nullptr; 963 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 964 int32_t encode = 0; 965 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 966 Type typeValue = static_cast<Type>(encode); 967 if (typeValue != Type::BASIC && typeValue != Type::BASIC_URL_SAFE) { 968 return ThrowError(env, "Parameter error. The target encoding type option must be BASIC or BASIC_URL_SAFE."); 969 } 970 Base64 *object = nullptr; 971 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 972 return object->EncodeSync(env, args[0], typeValue); 973 } 974 EncodeAsyncHelper(napi_env env,napi_callback_info info)975 static napi_value EncodeAsyncHelper(napi_env env, napi_callback_info info) 976 { 977 size_t argc = 2; // 2:The number of parameters is 2 978 napi_value args[2] = { nullptr }; 979 napi_value thisVar = nullptr; 980 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 981 int32_t encode = 0; 982 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 983 Type typeValue = static_cast<Type>(encode); 984 Base64 *object = nullptr; 985 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 986 return object->Encode(env, args[0], typeValue); 987 } 988 EncodeToStringAsyncHelper(napi_env env,napi_callback_info info)989 static napi_value EncodeToStringAsyncHelper(napi_env env, napi_callback_info info) 990 { 991 size_t argc = 2; // 2:The number of parameters is 2 992 napi_value args[2] = { nullptr }; 993 napi_value thisVar = nullptr; 994 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 995 int32_t encode = 0; 996 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 997 Type typeValue = static_cast<Type>(encode); 998 Base64 *object = nullptr; 999 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1000 napi_value result = object->EncodeToString(env, args[0], typeValue); 1001 return result; 1002 } 1003 DecodeBase64Helper(napi_env env,napi_callback_info info)1004 static napi_value DecodeBase64Helper(napi_env env, napi_callback_info info) 1005 { 1006 size_t argc = 2; // 2:The number of parameters is 2 1007 napi_value args[2] = { nullptr }; 1008 napi_value thisVar = nullptr; 1009 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1010 int32_t encode = 0; 1011 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1012 Type typeValue = static_cast<Type>(encode); 1013 if (typeValue < Type::TYPED_FIRST || typeValue > Type::TYPED_LAST) { 1014 return ThrowError(env, 1015 "Parameter error. The target encoding type option must be one of the Type enumerations."); 1016 } 1017 Base64 *object = nullptr; 1018 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1019 return object->DecodeSync(env, args[0], typeValue); 1020 } 1021 DecodeAsyncHelper(napi_env env,napi_callback_info info)1022 static napi_value DecodeAsyncHelper(napi_env env, napi_callback_info info) 1023 { 1024 size_t argc = 2; // 2:The number of parameters is 2 1025 napi_value args[2] = { nullptr }; 1026 napi_value thisVar = nullptr; 1027 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr)); 1028 int32_t encode = 0; 1029 NAPI_CALL(env, napi_get_value_int32(env, args[1], &encode)); 1030 Type typeValue = static_cast<Type>(encode); 1031 Base64 *object = nullptr; 1032 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1033 return object->Decode(env, args[0], typeValue); 1034 } 1035 1036 // Types TypesConstructor(napi_env env,napi_callback_info info)1037 static napi_value TypesConstructor(napi_env env, napi_callback_info info) 1038 { 1039 napi_value thisVar = nullptr; 1040 void* data = nullptr; 1041 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data)); 1042 auto objectInfo = new Types(); 1043 napi_status status = napi_wrap(env, thisVar, objectInfo, 1044 [](napi_env environment, void* data, void* hint) { 1045 auto objectInformation = reinterpret_cast<Types*>(data); 1046 if (objectInformation != nullptr) { 1047 delete objectInformation; 1048 objectInformation = nullptr; 1049 } 1050 }, nullptr, nullptr); 1051 if (status != napi_ok && objectInfo != nullptr) { 1052 delete objectInfo; 1053 objectInfo = nullptr; 1054 } 1055 return thisVar; 1056 } 1057 IsAnyArrayBuffer(napi_env env,napi_callback_info info)1058 static napi_value IsAnyArrayBuffer(napi_env env, napi_callback_info info) 1059 { 1060 napi_value thisVar = nullptr; 1061 size_t argc = 1; 1062 napi_value args = nullptr; 1063 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1064 Types* object = nullptr; 1065 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1066 napi_value rst = object->IsAnyArrayBuffer(env, args); 1067 return rst; 1068 } 1069 IsArrayBufferView(napi_env env,napi_callback_info info)1070 static napi_value IsArrayBufferView(napi_env env, napi_callback_info info) 1071 { 1072 napi_value thisVar = nullptr; 1073 size_t argc = 1; 1074 napi_value args = nullptr; 1075 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1076 Types* object = nullptr; 1077 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1078 napi_value rst = object->IsArrayBufferView(env, args); 1079 return rst; 1080 } 1081 IsArgumentsObject(napi_env env,napi_callback_info info)1082 static napi_value IsArgumentsObject(napi_env env, napi_callback_info info) 1083 { 1084 napi_value thisVar = nullptr; 1085 size_t argc = 1; 1086 napi_value args = nullptr; 1087 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1088 Types* object = nullptr; 1089 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1090 napi_value rst = object->IsArgumentsObject(env, args); 1091 return rst; 1092 } 1093 IsArrayBuffer(napi_env env,napi_callback_info info)1094 static napi_value IsArrayBuffer(napi_env env, napi_callback_info info) 1095 { 1096 napi_value thisVar = nullptr; 1097 size_t argc = 1; 1098 napi_value args = nullptr; 1099 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1100 Types* object = nullptr; 1101 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1102 napi_value rst = object->IsArrayBuffer(env, args); 1103 return rst; 1104 } 1105 IsAsyncFunction(napi_env env,napi_callback_info info)1106 static napi_value IsAsyncFunction(napi_env env, napi_callback_info info) 1107 { 1108 napi_value thisVar = nullptr; 1109 size_t argc = 1; 1110 napi_value args = nullptr; 1111 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1112 Types* object = nullptr; 1113 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1114 napi_value rst = object->IsAsyncFunction(env, args); 1115 return rst; 1116 } 1117 IsBigInt64Array(napi_env env,napi_callback_info info)1118 static napi_value IsBigInt64Array(napi_env env, napi_callback_info info) 1119 { 1120 napi_value thisVar = nullptr; 1121 size_t argc = 1; 1122 napi_value args = nullptr; 1123 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1124 Types* object = nullptr; 1125 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1126 napi_value rst = object->IsBigInt64Array(env, args); 1127 return rst; 1128 } 1129 IsBigUint64Array(napi_env env,napi_callback_info info)1130 static napi_value IsBigUint64Array(napi_env env, napi_callback_info info) 1131 { 1132 napi_value thisVar = nullptr; 1133 size_t argc = 1; 1134 napi_value args = nullptr; 1135 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1136 Types* object = nullptr; 1137 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1138 napi_value rst = object->IsBigUint64Array(env, args); 1139 return rst; 1140 } 1141 IsBooleanObject(napi_env env,napi_callback_info info)1142 static napi_value IsBooleanObject(napi_env env, napi_callback_info info) 1143 { 1144 napi_value thisVar = nullptr; 1145 size_t argc = 1; 1146 napi_value args = nullptr; 1147 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1148 Types* object = nullptr; 1149 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1150 napi_value rst = object->IsBooleanObject(env, args); 1151 return rst; 1152 } 1153 IsBoxedPrimitive(napi_env env,napi_callback_info info)1154 static napi_value IsBoxedPrimitive(napi_env env, napi_callback_info info) 1155 { 1156 napi_value thisVar = nullptr; 1157 size_t argc = 1; 1158 napi_value args = nullptr; 1159 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1160 Types* object = nullptr; 1161 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1162 napi_value rst = object->IsBoxedPrimitive(env, args); 1163 return rst; 1164 } 1165 IsDataView(napi_env env,napi_callback_info info)1166 static napi_value IsDataView(napi_env env, napi_callback_info info) 1167 { 1168 napi_value thisVar = nullptr; 1169 size_t argc = 1; 1170 napi_value args = nullptr; 1171 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1172 Types* object = nullptr; 1173 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1174 napi_value rst = object->IsDataView(env, args); 1175 return rst; 1176 } 1177 IsDate(napi_env env,napi_callback_info info)1178 static napi_value IsDate(napi_env env, napi_callback_info info) 1179 { 1180 napi_value thisVar = nullptr; 1181 size_t argc = 1; 1182 napi_value args = nullptr; 1183 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1184 Types* object = nullptr; 1185 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1186 napi_value rst = object->IsDate(env, args); 1187 return rst; 1188 } 1189 IsExternal(napi_env env,napi_callback_info info)1190 static napi_value IsExternal(napi_env env, napi_callback_info info) 1191 { 1192 napi_value thisVar = nullptr; 1193 size_t argc = 1; 1194 napi_value args = nullptr; 1195 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1196 Types* object = nullptr; 1197 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1198 napi_value rst = object->IsExternal(env, args); 1199 return rst; 1200 } 1201 IsFloat32Array(napi_env env,napi_callback_info info)1202 static napi_value IsFloat32Array(napi_env env, napi_callback_info info) 1203 { 1204 napi_value thisVar = nullptr; 1205 size_t argc = 1; 1206 napi_value args = nullptr; 1207 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1208 Types* object = nullptr; 1209 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1210 napi_value rst = object->IsFloat32Array(env, args); 1211 return rst; 1212 } 1213 IsFloat64Array(napi_env env,napi_callback_info info)1214 static napi_value IsFloat64Array(napi_env env, napi_callback_info info) 1215 { 1216 napi_value thisVar = nullptr; 1217 size_t argc = 1; 1218 napi_value args = nullptr; 1219 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1220 Types* object = nullptr; 1221 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1222 napi_value rst = object->IsFloat64Array(env, args); 1223 return rst; 1224 } 1225 IsGeneratorFunction(napi_env env,napi_callback_info info)1226 static napi_value IsGeneratorFunction(napi_env env, napi_callback_info info) 1227 { 1228 napi_value thisVar = nullptr; 1229 size_t argc = 1; 1230 napi_value args = nullptr; 1231 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1232 Types* object = nullptr; 1233 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1234 napi_value rst = object->IsGeneratorFunction(env, args); 1235 return rst; 1236 } 1237 IsGeneratorObject(napi_env env,napi_callback_info info)1238 static napi_value IsGeneratorObject(napi_env env, napi_callback_info info) 1239 { 1240 napi_value thisVar = nullptr; 1241 size_t requireArgc = 1; 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 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1246 Types* object = nullptr; 1247 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1248 napi_value result = object->IsGeneratorObject(env, args); 1249 return result; 1250 } 1251 IsInt8Array(napi_env env,napi_callback_info info)1252 static napi_value IsInt8Array(napi_env env, napi_callback_info info) 1253 { 1254 napi_value thisVar = nullptr; 1255 size_t requireArgc = 1; 1256 size_t argc = 1; 1257 napi_value args = nullptr; 1258 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1259 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1260 Types* object = nullptr; 1261 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1262 napi_value result = object->IsInt8Array(env, args); 1263 return result; 1264 } 1265 IsInt16Array(napi_env env,napi_callback_info info)1266 static napi_value IsInt16Array(napi_env env, napi_callback_info info) 1267 { 1268 napi_value thisVar = nullptr; 1269 size_t requireArgc = 1; 1270 size_t argc = 1; 1271 napi_value args = nullptr; 1272 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1273 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1274 Types* object = nullptr; 1275 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1276 napi_value result = object->IsInt16Array(env, args); 1277 return result; 1278 } 1279 IsInt32Array(napi_env env,napi_callback_info info)1280 static napi_value IsInt32Array(napi_env env, napi_callback_info info) 1281 { 1282 napi_value thisVar = nullptr; 1283 size_t requireArgc = 1; 1284 size_t argc = 1; 1285 napi_value args = nullptr; 1286 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1287 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1288 Types* object = nullptr; 1289 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1290 napi_value result = object->IsInt32Array(env, args); 1291 return result; 1292 } 1293 IsMap(napi_env env,napi_callback_info info)1294 static napi_value IsMap(napi_env env, napi_callback_info info) 1295 { 1296 napi_value thisVar = nullptr; 1297 size_t requireArgc = 1; 1298 size_t argc = 1; 1299 napi_value args = nullptr; 1300 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1301 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1302 Types* object = nullptr; 1303 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1304 napi_value result = object->IsMap(env, args); 1305 return result; 1306 } 1307 IsMapIterator(napi_env env,napi_callback_info info)1308 static napi_value IsMapIterator(napi_env env, napi_callback_info info) 1309 { 1310 napi_value thisVar = nullptr; 1311 size_t requireArgc = 1; 1312 size_t argc = 1; 1313 napi_value args = nullptr; 1314 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1315 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1316 Types* object = nullptr; 1317 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1318 napi_value result = object->IsMapIterator(env, args); 1319 return result; 1320 } 1321 IsModuleNamespaceObject(napi_env env,napi_callback_info info)1322 static napi_value IsModuleNamespaceObject(napi_env env, napi_callback_info info) 1323 { 1324 napi_value thisVar = nullptr; 1325 size_t requireArgc = 1; 1326 size_t argc = 1; 1327 napi_value args = nullptr; 1328 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1329 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1330 Types* object = nullptr; 1331 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1332 napi_value result = object->IsModuleNamespaceObject(env, args); 1333 return result; 1334 } 1335 IsNativeError(napi_env env,napi_callback_info info)1336 static napi_value IsNativeError(napi_env env, napi_callback_info info) 1337 { 1338 napi_value thisVar = nullptr; 1339 size_t requireArgc = 1; 1340 size_t argc = 1; 1341 napi_value args = nullptr; 1342 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1343 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1344 Types* object = nullptr; 1345 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1346 napi_value result = object->IsNativeError(env, args); 1347 return result; 1348 } 1349 IsNumberObject(napi_env env,napi_callback_info info)1350 static napi_value IsNumberObject(napi_env env, napi_callback_info info) 1351 { 1352 napi_value thisVar = nullptr; 1353 size_t requireArgc = 1; 1354 size_t argc = 1; 1355 napi_value args = nullptr; 1356 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1357 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1358 Types* object = nullptr; 1359 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1360 napi_value result = object->IsNumberObject(env, args); 1361 return result; 1362 } 1363 IsPromise(napi_env env,napi_callback_info info)1364 static napi_value IsPromise(napi_env env, napi_callback_info info) 1365 { 1366 napi_value thisVar = nullptr; 1367 size_t requireArgc = 1; 1368 size_t argc = 1; 1369 napi_value args = nullptr; 1370 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1371 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1372 Types* object = nullptr; 1373 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1374 napi_value result = object->IsPromise(env, args); 1375 return result; 1376 } 1377 IsProxy(napi_env env,napi_callback_info info)1378 static napi_value IsProxy(napi_env env, napi_callback_info info) 1379 { 1380 napi_value thisVar = nullptr; 1381 size_t requireArgc = 1; 1382 size_t argc = 1; 1383 napi_value args = nullptr; 1384 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1385 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1386 Types* object = nullptr; 1387 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1388 napi_value result = object->IsProxy(env, args); 1389 return result; 1390 } 1391 IsRegExp(napi_env env,napi_callback_info info)1392 static napi_value IsRegExp(napi_env env, napi_callback_info info) 1393 { 1394 napi_value thisVar = nullptr; 1395 size_t requireArgc = 1; 1396 size_t argc = 1; 1397 napi_value args = nullptr; 1398 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1399 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1400 Types* object = nullptr; 1401 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1402 napi_value result = object->IsRegExp(env, args); 1403 return result; 1404 } 1405 IsSet(napi_env env,napi_callback_info info)1406 static napi_value IsSet(napi_env env, napi_callback_info info) 1407 { 1408 napi_value thisVar = nullptr; 1409 size_t requireArgc = 1; 1410 size_t argc = 1; 1411 napi_value args = nullptr; 1412 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1413 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1414 Types* object = nullptr; 1415 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1416 napi_value result = object->IsSet(env, args); 1417 return result; 1418 } 1419 IsSetIterator(napi_env env,napi_callback_info info)1420 static napi_value IsSetIterator(napi_env env, napi_callback_info info) 1421 { 1422 napi_value thisVar = nullptr; 1423 size_t requireArgc = 1; 1424 size_t argc = 1; 1425 napi_value args = nullptr; 1426 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1427 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1428 Types* object = nullptr; 1429 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1430 napi_value result = object->IsSetIterator(env, args); 1431 return result; 1432 } 1433 IsSharedArrayBuffer(napi_env env,napi_callback_info info)1434 static napi_value IsSharedArrayBuffer(napi_env env, napi_callback_info info) 1435 { 1436 napi_value thisVar = nullptr; 1437 size_t requireArgc = 1; 1438 size_t argc = 1; 1439 napi_value args = nullptr; 1440 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1441 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1442 Types* object = nullptr; 1443 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1444 napi_value result = object->IsSharedArrayBuffer(env, args); 1445 return result; 1446 } 1447 IsStringObject(napi_env env,napi_callback_info info)1448 static napi_value IsStringObject(napi_env env, napi_callback_info info) 1449 { 1450 napi_value thisVar = nullptr; 1451 size_t requireArgc = 1; 1452 size_t argc = 1; 1453 napi_value args = nullptr; 1454 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1455 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1456 Types* object = nullptr; 1457 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1458 napi_value result = object->IsStringObject(env, args); 1459 return result; 1460 } 1461 IsSymbolObject(napi_env env,napi_callback_info info)1462 static napi_value IsSymbolObject(napi_env env, napi_callback_info info) 1463 { 1464 napi_value thisVar = nullptr; 1465 size_t requireArgc = 1; 1466 size_t argc = 1; 1467 napi_value args = nullptr; 1468 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1469 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1470 Types* object = nullptr; 1471 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1472 napi_value result = object->IsSymbolObject(env, args); 1473 return result; 1474 } 1475 IsTypedArray(napi_env env,napi_callback_info info)1476 static napi_value IsTypedArray(napi_env env, napi_callback_info info) 1477 { 1478 napi_value thisVar = nullptr; 1479 size_t requireArgc = 1; 1480 size_t argc = 1; 1481 napi_value args = nullptr; 1482 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1483 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1484 Types* object = nullptr; 1485 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1486 napi_value result = object->IsTypedArray(env, args); 1487 return result; 1488 } 1489 IsUint8Array(napi_env env,napi_callback_info info)1490 static napi_value IsUint8Array(napi_env env, napi_callback_info info) 1491 { 1492 napi_value thisVar = nullptr; 1493 size_t requireArgc = 1; 1494 size_t argc = 1; 1495 napi_value args = nullptr; 1496 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1497 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1498 Types* object = nullptr; 1499 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1500 napi_value result = object->IsUint8Array(env, args); 1501 return result; 1502 } 1503 IsUint8ClampedArray(napi_env env,napi_callback_info info)1504 static napi_value IsUint8ClampedArray(napi_env env, napi_callback_info info) 1505 { 1506 napi_value thisVar = nullptr; 1507 size_t requireArgc = 1; 1508 size_t argc = 1; 1509 napi_value args = nullptr; 1510 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1511 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1512 Types* object = nullptr; 1513 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1514 napi_value result = object->IsUint8ClampedArray(env, args); 1515 return result; 1516 } 1517 IsUint16Array(napi_env env,napi_callback_info info)1518 static napi_value IsUint16Array(napi_env env, napi_callback_info info) 1519 { 1520 napi_value thisVar = nullptr; 1521 size_t requireArgc = 1; 1522 size_t argc = 1; 1523 napi_value args = nullptr; 1524 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1525 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1526 Types* object = nullptr; 1527 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1528 napi_value result = object->IsUint16Array(env, args); 1529 return result; 1530 } 1531 IsUint32Array(napi_env env,napi_callback_info info)1532 static napi_value IsUint32Array(napi_env env, napi_callback_info info) 1533 { 1534 napi_value thisVar = nullptr; 1535 size_t requireArgc = 1; 1536 size_t argc = 1; 1537 napi_value args = nullptr; 1538 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1539 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1540 Types* object = nullptr; 1541 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1542 napi_value result = object->IsUint32Array(env, args); 1543 return result; 1544 } 1545 IsWeakMap(napi_env env,napi_callback_info info)1546 static napi_value IsWeakMap(napi_env env, napi_callback_info info) 1547 { 1548 napi_value thisVar = nullptr; 1549 size_t requireArgc = 1; 1550 size_t argc = 1; 1551 napi_value args = nullptr; 1552 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1553 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1554 Types* object = nullptr; 1555 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1556 napi_value result = object->IsWeakMap(env, args); 1557 return result; 1558 } 1559 IsWeakSet(napi_env env,napi_callback_info info)1560 static napi_value IsWeakSet(napi_env env, napi_callback_info info) 1561 { 1562 napi_value thisVar = nullptr; 1563 size_t requireArgc = 1; 1564 size_t argc = 1; 1565 napi_value args = nullptr; 1566 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, &thisVar, nullptr)); 1567 NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments"); 1568 Types* object = nullptr; 1569 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1570 napi_value result = object->IsWeakSet(env, args); 1571 return result; 1572 } 1573 1574 // StringDecoder StringDecoderConstructor(napi_env env,napi_callback_info info)1575 static napi_value StringDecoderConstructor(napi_env env, napi_callback_info info) 1576 { 1577 size_t argc = 1; 1578 napi_value thisVar = nullptr; 1579 napi_value argv = nullptr; 1580 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1581 std::string enconding = "utf-8"; 1582 if (argc == 1) { 1583 napi_valuetype valuetype; 1584 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1585 if (valuetype == napi_string) { 1586 size_t bufferSize = 0; 1587 if (napi_get_value_string_utf8(env, argv, nullptr, 0, &bufferSize) != napi_ok) { 1588 HILOG_ERROR("StringDecoder:: can not get argv size"); 1589 return nullptr; 1590 } 1591 std::string buffer = ""; 1592 buffer.reserve(bufferSize); 1593 buffer.resize(bufferSize); 1594 if (napi_get_value_string_utf8(env, argv, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 1595 HILOG_ERROR("StringDecoder:: can not get argv value"); 1596 return nullptr; 1597 } 1598 if (!CheckEncodingFormat(buffer)) { 1599 napi_throw_error(env, "401", 1600 "Parameter error. Wrong encoding format, the current encoding format is not support."); 1601 return nullptr; 1602 } 1603 enconding = buffer; 1604 } 1605 } 1606 auto objectInfo = new StringDecoder(enconding); 1607 napi_status status = napi_wrap(env, thisVar, objectInfo, 1608 [](napi_env environment, void* data, void* hint) { 1609 auto obj = reinterpret_cast<StringDecoder*>(data); 1610 if (obj != nullptr) { 1611 delete obj; 1612 obj = nullptr; 1613 } 1614 }, nullptr, nullptr); 1615 if (status != napi_ok && objectInfo != nullptr) { 1616 HILOG_ERROR("StringDecoderConstructor:: napi_wrap failed."); 1617 delete objectInfo; 1618 objectInfo = nullptr; 1619 } 1620 return thisVar; 1621 } 1622 Write(napi_env env,napi_callback_info info)1623 static napi_value Write(napi_env env, napi_callback_info info) 1624 { 1625 napi_value thisVar = nullptr; 1626 size_t argc = 1; 1627 napi_value argv = nullptr; 1628 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1629 napi_valuetype valuetype; 1630 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1631 if (valuetype == napi_string) { 1632 return argv; 1633 } 1634 StringDecoder *object = nullptr; 1635 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1636 return object->Write(env, argv); 1637 } 1638 End(napi_env env,napi_callback_info info)1639 static napi_value End(napi_env env, napi_callback_info info) 1640 { 1641 napi_value thisVar = nullptr; 1642 size_t argc = 1; 1643 napi_value argv = nullptr; 1644 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, nullptr)); 1645 StringDecoder *object = nullptr; 1646 NAPI_CALL(env, napi_unwrap(env, thisVar, (void**)&object)); 1647 if (argc == 0) { 1648 return object->End(env); 1649 } 1650 napi_valuetype valuetype; 1651 NAPI_CALL(env, napi_typeof(env, argv, &valuetype)); 1652 if (valuetype == napi_string) { 1653 return argv; 1654 } 1655 if (valuetype == napi_undefined) { 1656 return object->End(env); 1657 } 1658 return object->End(env, argv); 1659 } 1660 TypeofInit(napi_env env,napi_value exports)1661 static napi_value TypeofInit(napi_env env, napi_value exports) 1662 { 1663 const char* typeofClassName = "Types"; 1664 napi_value typeofClass = nullptr; 1665 napi_property_descriptor typeofDesc[] = { 1666 DECLARE_NAPI_FUNCTION("isBigInt64Array", IsBigInt64Array), 1667 DECLARE_NAPI_FUNCTION("isBigUint64Array", IsBigUint64Array), 1668 DECLARE_NAPI_FUNCTION("isBooleanObject", IsBooleanObject), 1669 DECLARE_NAPI_FUNCTION("isBoxedPrimitive", IsBoxedPrimitive), 1670 DECLARE_NAPI_FUNCTION("isAnyArrayBuffer", IsAnyArrayBuffer), 1671 DECLARE_NAPI_FUNCTION("isArrayBufferView", IsArrayBufferView), 1672 DECLARE_NAPI_FUNCTION("isArgumentsObject", IsArgumentsObject), 1673 DECLARE_NAPI_FUNCTION("isArrayBuffer", IsArrayBuffer), 1674 DECLARE_NAPI_FUNCTION("isDataView", IsDataView), 1675 DECLARE_NAPI_FUNCTION("isDate", IsDate), 1676 DECLARE_NAPI_FUNCTION("isExternal", IsExternal), 1677 DECLARE_NAPI_FUNCTION("isFloat32Array", IsFloat32Array), 1678 DECLARE_NAPI_FUNCTION("isFloat64Array", IsFloat64Array), 1679 DECLARE_NAPI_FUNCTION("isGeneratorFunction", IsGeneratorFunction), 1680 DECLARE_NAPI_FUNCTION("isGeneratorObject", IsGeneratorObject), 1681 DECLARE_NAPI_FUNCTION("isInt8Array", IsInt8Array), 1682 DECLARE_NAPI_FUNCTION("isInt16Array", IsInt16Array), 1683 DECLARE_NAPI_FUNCTION("isInt32Array", IsInt32Array), 1684 DECLARE_NAPI_FUNCTION("isMap", IsMap), 1685 DECLARE_NAPI_FUNCTION("isMapIterator", IsMapIterator), 1686 DECLARE_NAPI_FUNCTION("isModuleNamespaceObject", IsModuleNamespaceObject), 1687 DECLARE_NAPI_FUNCTION("isNativeError", IsNativeError), 1688 DECLARE_NAPI_FUNCTION("isNumberObject", IsNumberObject), 1689 DECLARE_NAPI_FUNCTION("isPromise", IsPromise), 1690 DECLARE_NAPI_FUNCTION("isProxy", IsProxy), 1691 DECLARE_NAPI_FUNCTION("isRegExp", IsRegExp), 1692 DECLARE_NAPI_FUNCTION("isSet", IsSet), 1693 DECLARE_NAPI_FUNCTION("isSetIterator", IsSetIterator), 1694 DECLARE_NAPI_FUNCTION("isSharedArrayBuffer", IsSharedArrayBuffer), 1695 DECLARE_NAPI_FUNCTION("isStringObject", IsStringObject), 1696 DECLARE_NAPI_FUNCTION("isSymbolObject", IsSymbolObject), 1697 DECLARE_NAPI_FUNCTION("isTypedArray", IsTypedArray), 1698 DECLARE_NAPI_FUNCTION("isUint8Array", IsUint8Array), 1699 DECLARE_NAPI_FUNCTION("isUint8ClampedArray", IsUint8ClampedArray), 1700 DECLARE_NAPI_FUNCTION("isUint16Array", IsUint16Array), 1701 DECLARE_NAPI_FUNCTION("isUint32Array", IsUint32Array), 1702 DECLARE_NAPI_FUNCTION("isWeakMap", IsWeakMap), 1703 DECLARE_NAPI_FUNCTION("isWeakSet", IsWeakSet), 1704 DECLARE_NAPI_FUNCTION("isAsyncFunction", IsAsyncFunction), 1705 }; 1706 NAPI_CALL(env, napi_define_class(env, typeofClassName, strlen(typeofClassName), TypesConstructor, 1707 nullptr, sizeof(typeofDesc) / sizeof(typeofDesc[0]), typeofDesc, 1708 &typeofClass)); 1709 napi_property_descriptor desc[] = { DECLARE_NAPI_PROPERTY("Types", typeofClass) }; 1710 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1711 return exports; 1712 } 1713 Base64Init(napi_env env,napi_value exports)1714 static napi_value Base64Init(napi_env env, napi_value exports) 1715 { 1716 const char *base64ClassName = "Base64"; 1717 napi_value base64Class = nullptr; 1718 napi_property_descriptor base64Desc[] = { 1719 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64), 1720 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToString), 1721 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64), 1722 DECLARE_NAPI_FUNCTION("encode", EncodeAsync), 1723 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsync), 1724 DECLARE_NAPI_FUNCTION("decode", DecodeAsync), 1725 }; 1726 NAPI_CALL(env, napi_define_class(env, base64ClassName, strlen(base64ClassName), Base64Constructor, 1727 nullptr, sizeof(base64Desc) / sizeof(base64Desc[0]), base64Desc, 1728 &base64Class)); 1729 napi_property_descriptor desc[] = { 1730 DECLARE_NAPI_PROPERTY("Base64", base64Class) 1731 }; 1732 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1733 return exports; 1734 } 1735 Base64HelperInit(napi_env env,napi_value exports)1736 static napi_value Base64HelperInit(napi_env env, napi_value exports) 1737 { 1738 const char *base64HelperClassName = "Base64Helper"; 1739 napi_value Base64HelperClass = nullptr; 1740 napi_property_descriptor Base64HelperDesc[] = { 1741 DECLARE_NAPI_FUNCTION("encodeSync", EncodeBase64Helper), 1742 DECLARE_NAPI_FUNCTION("encodeToStringSync", EncodeToStringHelper), 1743 DECLARE_NAPI_FUNCTION("decodeSync", DecodeBase64Helper), 1744 DECLARE_NAPI_FUNCTION("encode", EncodeAsyncHelper), 1745 DECLARE_NAPI_FUNCTION("encodeToString", EncodeToStringAsyncHelper), 1746 DECLARE_NAPI_FUNCTION("decode", DecodeAsyncHelper), 1747 }; 1748 NAPI_CALL(env, napi_define_class(env, base64HelperClassName, strlen(base64HelperClassName), Base64Constructor, 1749 nullptr, sizeof(Base64HelperDesc) / sizeof(Base64HelperDesc[0]), 1750 Base64HelperDesc, &Base64HelperClass)); 1751 napi_property_descriptor desc[] = { 1752 DECLARE_NAPI_PROPERTY("Base64Helper", Base64HelperClass) 1753 }; 1754 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1755 return exports; 1756 } 1757 StringDecoderInit(napi_env env,napi_value exports)1758 static napi_value StringDecoderInit(napi_env env, napi_value exports) 1759 { 1760 const char *stringDecoderClassName = "StringDecoder"; 1761 napi_value StringDecoderClass = nullptr; 1762 napi_property_descriptor StringDecoderDesc[] = { 1763 DECLARE_NAPI_FUNCTION("write", Write), 1764 DECLARE_NAPI_FUNCTION("end", End), 1765 }; 1766 NAPI_CALL(env, napi_define_class(env, stringDecoderClassName, strlen(stringDecoderClassName), 1767 StringDecoderConstructor, nullptr, 1768 sizeof(StringDecoderDesc) / sizeof(StringDecoderDesc[0]), 1769 StringDecoderDesc, &StringDecoderClass)); 1770 napi_property_descriptor desc[] = { 1771 DECLARE_NAPI_PROPERTY("StringDecoder", StringDecoderClass) 1772 }; 1773 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1774 return exports; 1775 } 1776 UtilInit(napi_env env,napi_value exports)1777 static napi_value UtilInit(napi_env env, napi_value exports) 1778 { 1779 napi_property_descriptor desc[] = { 1780 DECLARE_NAPI_FUNCTION("printf", Printf), 1781 DECLARE_NAPI_FUNCTION("format", Printf), 1782 DECLARE_NAPI_FUNCTION("geterrorstring", GetErrorString), 1783 DECLARE_NAPI_FUNCTION("errnoToString", GetErrorString), 1784 DECLARE_NAPI_FUNCTION("dealwithformatstring", DealWithFormatString), 1785 DECLARE_NAPI_FUNCTION("randomUUID", RandomUUID), 1786 DECLARE_NAPI_FUNCTION("randomBinaryUUID", RandomBinaryUUID), 1787 DECLARE_NAPI_FUNCTION("parseUUID", ParseUUID), 1788 DECLARE_NAPI_FUNCTION("getHash", GetHash) 1789 }; 1790 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); 1791 TextcoderInit(env, exports); 1792 Base64Init(env, exports); 1793 Base64HelperInit(env, exports); 1794 TypeofInit(env, exports); 1795 StringDecoderInit(env, exports); 1796 return exports; 1797 } 1798 1799 // util JS register 1800 extern "C" NAPI_util_GetJSCode(const char ** buf,int * buflen)1801 __attribute__((visibility("default"))) void NAPI_util_GetJSCode(const char **buf, int *buflen) 1802 { 1803 if (buf != nullptr) { 1804 *buf = _binary_util_js_js_start; 1805 } 1806 if (buflen != nullptr) { 1807 *buflen = _binary_util_js_js_end - _binary_util_js_js_start; 1808 } 1809 } 1810 extern "C" NAPI_util_GetABCCode(const char ** buf,int * buflen)1811 __attribute__((visibility("default"))) void NAPI_util_GetABCCode(const char** buf, int* buflen) 1812 { 1813 if (buf != nullptr) { 1814 *buf = _binary_util_abc_start; 1815 } 1816 if (buflen != nullptr) { 1817 *buflen = _binary_util_abc_end - _binary_util_abc_start; 1818 } 1819 } 1820 1821 // util module define 1822 static napi_module_with_js utilModule = { 1823 .nm_version = 1, 1824 .nm_flags = 0, 1825 .nm_filename = nullptr, 1826 .nm_register_func = UtilInit, 1827 .nm_modname = "util", 1828 .nm_priv = ((void*)0), 1829 .nm_get_abc_code = NAPI_util_GetABCCode, 1830 .nm_get_js_code = NAPI_util_GetJSCode, 1831 }; 1832 // util module register 1833 extern "C" UtilRegisterModule()1834 __attribute__((constructor)) void UtilRegisterModule() 1835 { 1836 napi_module_with_js_register(&utilModule); 1837 UtilPluginJniRegister(); 1838 } 1839 } 1840