napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
size_t argc = 1;
napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
napi_valuetype argument_type;
NAPI_CALL(env, napi_typeof(env, args[0], &argument_type));
napi_value result = NULL;
if (argument_type == napi_number) {
NAPI_CALL(env, napi_create_string_utf8(env, "number", -1, &result));
} else if (argument_type == napi_string) {
NAPI_CALL(env, napi_create_string_utf8(env, "string", -1, &result));
} else if (argument_type == napi_function) {
NAPI_CALL(env, napi_create_string_utf8(env, "function", -1, &result));
} else if (argument_type == napi_object) {
NAPI_CALL(env, napi_create_string_utf8(env, "object", -1, &result));
} else if (argument_type == napi_boolean) {
NAPI_CALL(env, napi_create_string_utf8(env, "boolean", -1, &result));
} else if (argument_type == napi_undefined) {
NAPI_CALL(env, napi_create_string_utf8(env, "undefined", -1, &result));
} else if (argument_type == napi_symbol) {
NAPI_CALL(env, napi_create_string_utf8(env, "symbol", -1, &result));
} else if (argument_type == napi_null) {
NAPI_CALL(env, napi_create_string_utf8(env, "null", -1, &result));
}
return result;
}
napi_value RunCallback(napi_env env, napi_callback_info info) {
size_t argc = 2;
napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc == 1,
"Wrong number of arguments. Expects a single argument.");
napi_valuetype valuetype0;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
NAPI_ASSERT(env, valuetype0 == napi_function,
"Wrong type of arguments. Expects a function as first argument.");
napi_valuetype valuetype1;
NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
NAPI_ASSERT(env, valuetype1 == napi_undefined,
"Additional arguments should be undefined.");
napi_value argv[1];
const char* str = "hello world";
size_t str_len = strlen(str);
NAPI_CALL(env, napi_create_string_utf8(env, str, str_len, argv));
napi_value global;
NAPI_CALL(env, napi_get_global(env, &global));
napi_value cb = args[0];
NAPI_CALL(env, napi_call_function(env, global, cb, 1, argv, NULL));
return NULL;
}
napi_value Method(napi_env env, napi_callback_info info) {
napi_value world;
const char* str = "world";
size_t str_len = strlen(str);
NAPI_CALL(env, napi_create_string_utf8(env, str, str_len, &world));
return world;
}
napi_value TestUtf8(napi_env env, napi_callback_info info) {
size_t argc = 1;
napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
napi_valuetype valuetype;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
NAPI_ASSERT(env, valuetype == napi_string,
"Wrong type of argment. Expects a string.");
char buffer[128];
size_t buffer_size = 128;
size_t copied;
NAPI_CALL(env,
napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
napi_value output;
NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
return output;
}
napi_value bufferInfo(napi_env env, napi_callback_info info){
size_t argc=1;
napi_value args[1];
napi_status status;
//napi_valuetype valuetype;
//bool valuetype;
status=napi_get_cb_info(env, info, &argc, args,NULL,NULL);
if(status !=napi_ok){return NULL;}
//assert(status==napi_ok);
//if(argc > 1){napi_throw_type_error(env,nullptr,"Wrong number of arguments!");
// return NULL;
//}
//status=napi_is_buffer(env,args[0], &valuetype);
//if(status !=napi_ok){return status;}
//assert(status==napi_ok);
//if(valuetype == false){
//napi_throw_type_error(env,nullptr,"Wrong type of argument. Expects a buffer!");
//return NULL;
//}
napi_value theBuffer=args[0], ua_family;
const char* bufferData;
napi_value obj;
//size_t bufferLength;
status=napi_get_buffer_info(env,theBuffer,(void**)(&bufferData),/*&bufferLength*/NULL);
if(status !=napi_ok){return NULL;}
//assert(status==napi_ok);
//printf("here: %s\n",bufferData);
//printf("here len: %zu\n",bufferLength);
//printf("sizeof(theText): %zu\n",sizeof(theText));
//status=napi_get_boolean(env,!strcmp(bufferData,theText) && bufferLength==sizeof(theText),&returnValue);
//assert(status==napi_ok);
//struct user_agent_parser *ua_parser = user_agent_parser_create();
//struct user_agent_info *ua_info = user_agent_info_create();
//user_agent_parser_read_buffer(ua_parser, ___uap_core_regexes_yaml, ___uap_core_regexes_yaml_len);
status=napi_create_object(env,&obj);
if(status !=napi_ok){return NULL;}
if (user_agent_parser_parse_string(ua_parser, ua_info,bufferData)) {
//status=
napi_create_string_utf8(env,ua_info->user_agent.family,NAPI_AUTO_LENGTH,&ua_family);
//if(status !=napi_ok){return NULL;}
//assert(status==napi_ok);
//assert(status==napi_ok);
//status=napi_set_named_property(env,obj,"ua_family",ua_family);//major,minor,patch
//if(status !=napi_ok){return NULL;}
//assert(status==napi_ok);
}
napi_property_descriptor descriptors[]={
{"ua_family",NULL,0,0,0,ua_family,napi_default,0}
};
status=napi_define_properties(env,obj,sizeof(descriptors)/sizeof(descriptors[0]),descriptors);
//assert(status==napi_ok);
//user_agent_parser_destroy(ua_parser);
//user_agent_info_destroy(ua_info);
return obj;
}
napi_value SayHello(napi_env env, napi_callback_info info) {
size_t argc = 0;
// test if `napi_get_cb_info` tolerants NULL pointers.
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL));
napi_value str;
NAPI_CALL(env, napi_create_string_utf8(env, "Hello", 5, &str));
return str;
}
napi_value Init(napi_env env, napi_value exports) {
napi_value number;
NAPI_CALL(env, napi_create_double(env, value_, &number));
napi_value name_value;
NAPI_CALL(env, napi_create_string_utf8(env,
"NameKeyValue",
NAPI_AUTO_LENGTH,
&name_value));
napi_value symbol_description;
napi_value name_symbol;
NAPI_CALL(env, napi_create_string_utf8(env,
"NameKeySymbol",
NAPI_AUTO_LENGTH,
&symbol_description));
NAPI_CALL(env, napi_create_symbol(env,
symbol_description,
&name_symbol));
napi_property_descriptor properties[] = {
{ "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
{ "readwriteValue", 0, 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
{ "readonlyValue", 0, 0, 0, 0, number, napi_enumerable, 0},
{ "hiddenValue", 0, 0, 0, 0, number, napi_default, 0},
{ NULL, name_value, 0, 0, 0, number, napi_enumerable, 0},
{ NULL, name_symbol, 0, 0, 0, number, napi_enumerable, 0},
{ "readwriteAccessor1", 0, 0, GetValue, SetValue, 0, napi_default, 0},
{ "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
{ "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},
{ "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0},
{ "hasNamedProperty", 0, HasNamedProperty, 0, 0, 0, napi_default, 0 },
};
NAPI_CALL(env, napi_define_properties(
env, exports, sizeof(properties) / sizeof(*properties), properties));
return exports;
}
napi_value bEnd(napi_env env, napi_callback_info info){
user_agent_parser_destroy(ua_parser);
ua_parser=NULL;
user_agent_info_destroy(ua_info);
ua_info=NULL;
napi_value mir;
const char* str2="ok";
size_t str_len2=strlen(str2);
napi_status status;
status=napi_create_string_utf8(env,str2,str_len2,&mir);
if(status !=napi_ok){return NULL;}
return mir;
}
napi_value bInit(napi_env env, napi_callback_info info){
int a;
napi_value world;
ua_parser=user_agent_parser_create();
ua_info=user_agent_info_create();
a=user_agent_parser_read_buffer(ua_parser,___uap_core_regexes_yaml,___uap_core_regexes_yaml_len);
printf("zustand: %d\n",a);
const char* str="ok";
size_t str_len=strlen(str);
napi_status status;
status=napi_create_string_utf8(env,str,str_len,&world);
if(status !=napi_ok){return NULL;}
return world;
}
napi_value Test(napi_env env, napi_callback_info info) {
size_t argc = 2;
napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
napi_valuetype valuetype0;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
NAPI_ASSERT(env, valuetype0 == napi_object,
"Wrong type of arguments. Expects an array as first argument.");
napi_valuetype valuetype1;
NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
NAPI_ASSERT(env, valuetype1 == napi_number,
"Wrong type of arguments. Expects an integer as second argument.");
napi_value array = args[0];
int32_t index;
NAPI_CALL(env, napi_get_value_int32(env, args[1], &index));
NAPI_ASSERT(env, index >= 0, "Invalid index. Expects a positive integer.");
bool isarray;
NAPI_CALL(env, napi_is_array(env, array, &isarray));
if (!isarray) {
return NULL;
}
uint32_t length;
NAPI_CALL(env, napi_get_array_length(env, array, &length));
if ((uint32_t)index >= length) {
napi_value str;
const char* str_val = "Index out of bound!";
size_t str_len = strlen(str_val);
NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
return str;
}
napi_value ret;
NAPI_CALL(env, napi_get_element(env, array, index, &ret));
return ret;
}
static napi_value CreateAsyncResource(napi_env env, napi_callback_info info) {
napi_value object;
NAPI_CALL(env, napi_create_object(env, &object));
napi_value resource_name;
NAPI_CALL(env, napi_create_string_utf8(
env, "test_gcable", NAPI_AUTO_LENGTH, &resource_name));
napi_async_context context;
NAPI_CALL(env, napi_async_init(env, object, resource_name, &context));
NAPI_CALL(env, napi_add_finalizer(
env, object, (void*)context, AsyncDestroyCb, NULL, NULL));
return object;
}
napi_value New(napi_env env, napi_callback_info info) {
napi_value ret;
NAPI_CALL(env, napi_create_object(env, &ret));
napi_value num;
NAPI_CALL(env, napi_create_int32(env, 987654321, &num));
NAPI_CALL(env, napi_set_named_property(env, ret, "test_number", num));
napi_value str;
const char* str_val = "test string";
size_t str_len = strlen(str_val);
NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
NAPI_CALL(env, napi_set_named_property(env, ret, "test_string", str));
return ret;
}
static napi_value createNapiError(napi_env env, napi_callback_info info) {
napi_value value;
NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
double double_value;
napi_status status = napi_get_value_double(env, value, &double_value);
NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
const napi_extended_error_info *error_info = 0;
NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
NAPI_ASSERT(env, error_info->error_code == status,
"Last error info code should match last status");
NAPI_ASSERT(env, error_info->error_message,
"Last error info message should not be null");
return NULL;
}
static napi_value MakeCallback(napi_env env, napi_callback_info info) {
size_t argc = MAX_ARGUMENTS;
size_t n;
napi_value args[MAX_ARGUMENTS];
// NOLINTNEXTLINE (readability/null_usage)
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
napi_value recv = args[0];
napi_value func = args[1];
napi_value argv[MAX_ARGUMENTS - 2];
for (n = 2; n < argc; n += 1) {
argv[n - 2] = args[n];
}
napi_valuetype func_type;
NAPI_CALL(env, napi_typeof(env, func, &func_type));
napi_value resource_name;
NAPI_CALL(env, napi_create_string_utf8(
env, "test", NAPI_AUTO_LENGTH, &resource_name));
napi_async_context context;
NAPI_CALL(env, napi_async_init(env, func, resource_name, &context));
napi_value result;
if (func_type == napi_function) {
NAPI_CALL(env, napi_make_callback(
env, context, recv, func, argc - 2, argv, &result));
} else {
NAPI_ASSERT(env, false, "Unexpected argument type");
}
NAPI_CALL(env, napi_async_destroy(env, context));
return result;
}
static napi_value Init(napi_env env, napi_value exports) {
napi_value theValue;
NAPI_CALL(env,
napi_create_string_utf8(env, theText, sizeof(theText), &theValue));
NAPI_CALL(env, napi_set_named_property(env, exports, "theText", theValue));
napi_property_descriptor methods[] = {
DECLARE_NAPI_PROPERTY("newBuffer", newBuffer),
DECLARE_NAPI_PROPERTY("newExternalBuffer", newExternalBuffer),
DECLARE_NAPI_PROPERTY("getDeleterCallCount", getDeleterCallCount),
DECLARE_NAPI_PROPERTY("copyBuffer", copyBuffer),
DECLARE_NAPI_PROPERTY("bufferHasInstance", bufferHasInstance),
DECLARE_NAPI_PROPERTY("bufferInfo", bufferInfo),
DECLARE_NAPI_PROPERTY("staticBuffer", staticBuffer),
};
NAPI_CALL(env, napi_define_properties(
env, exports, sizeof(methods) / sizeof(methods[0]), methods));
return exports;
}
void Test(napi_env env, napi_callback_info info) {
napi_status status;
size_t argc;
status = napi_get_cb_args_length(env, info, &argc);
if (status != napi_ok) return;
if (argc < 2) {
napi_throw_type_error(env, "Wrong number of arguments");
return;
}
napi_value args[2];
status = napi_get_cb_args(env, info, args, 2);
if (status != napi_ok) return;
napi_valuetype valuetype0;
status = napi_typeof(env, args[0], &valuetype0);
if (status != napi_ok) return;
if (valuetype0 != napi_object) {
napi_throw_type_error(
env, "Wrong type of argments. Expects an array as first argument.");
return;
}
napi_valuetype valuetype1;
status = napi_typeof(env, args[1], &valuetype1);
if (status != napi_ok) return;
if (valuetype1 != napi_number) {
napi_throw_type_error(
env, "Wrong type of argments. Expects an integer as second argument.");
return;
}
napi_value array = args[0];
int index;
status = napi_get_value_int32(env, args[1], &index);
if (status != napi_ok) return;
bool isarray;
status = napi_is_array(env, array, &isarray);
if (status != napi_ok) return;
if (isarray) {
uint32_t size;
status = napi_get_array_length(env, array, &size);
if (status != napi_ok) return;
if (index >= (int)(size)) {
napi_value str;
status = napi_create_string_utf8(env, "Index out of bound!", -1, &str);
if (status != napi_ok) return;
status = napi_set_return_value(env, info, str);
if (status != napi_ok) return;
} else if (index < 0) {
napi_throw_type_error(env, "Invalid index. Expects a positive integer.");
} else {
napi_value ret;
status = napi_get_element(env, array, index, &ret);
if (status != napi_ok) return;
status = napi_set_return_value(env, info, ret);
if (status != napi_ok) return;
}
}
}
napi_value MyFunction(napi_env env, napi_callback_info info) {
napi_value str;
NAPI_CALL(env, napi_create_string_utf8(env, "hello world", -1, &str));
return str;
}
