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