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