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