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