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