emnapi 1.2.0 → 1.3.1

package/include/node/js_native_api.h

@@ -56,7 +56,7 @@
 EXTERN_C_START
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
-    node_api_nogc_env env, const napi_extended_error_info** result);
+    node_api_basic_env env, const napi_extended_error_info** result);
 
 // Getters for defined singletons
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env,
@@ -100,19 +100,19 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
                                                             napi_value* result);
 #ifdef NAPI_EXPERIMENTAL
 #define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS
-NAPI_EXTERN napi_status NAPI_CDECL
-node_api_create_external_string_latin1(napi_env env,
-                                       char* str,
-                                       size_t length,
-                                       node_api_nogc_finalize finalize_callback,
-                                       void* finalize_hint,
-                                       napi_value* result,
-                                       bool* copied);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1(
+    napi_env env,
+    char* str,
+    size_t length,
+    node_api_basic_finalize finalize_callback,
+    void* finalize_hint,
+    napi_value* result,
+    bool* copied);
 NAPI_EXTERN napi_status NAPI_CDECL
 node_api_create_external_string_utf16(napi_env env,
                                       char16_t* str,
                                       size_t length,
-                                      node_api_nogc_finalize finalize_callback,
+                                      node_api_basic_finalize finalize_callback,
                                       void* finalize_hint,
                                       napi_value* result,
                                       bool* copied);
@@ -120,6 +120,10 @@ node_api_create_external_string_utf16(napi_env env,
 
 #ifdef NAPI_EXPERIMENTAL
 #define NODE_API_EXPERIMENTAL_HAS_PROPERTY_KEYS
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1(
+    napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8(
+    napi_env env, const char* str, size_t length, napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16(
     napi_env env, const char16_t* str, size_t length, napi_value* result);
 #endif  // NAPI_EXPERIMENTAL
@@ -324,12 +328,13 @@ napi_define_class(napi_env env,
                   napi_value* result);
 
 // Methods to work with external data objects
-NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env,
-                                             napi_value js_object,
-                                             void* native_object,
-                                             node_api_nogc_finalize finalize_cb,
-                                             void* finalize_hint,
-                                             napi_ref* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_wrap(napi_env env,
+          napi_value js_object,
+          void* native_object,
+          node_api_basic_finalize finalize_cb,
+          void* finalize_hint,
+          napi_ref* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env,
                                                napi_value js_object,
                                                void** result);
@@ -339,7 +344,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external(napi_env env,
                      void* data,
-                     node_api_nogc_finalize finalize_cb,
+                     node_api_basic_finalize finalize_cb,
                      void* finalize_hint,
                      napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env,
@@ -438,7 +443,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external_arraybuffer(napi_env env,
                                  void* external_data,
                                  size_t byte_length,
-                                 node_api_nogc_finalize finalize_cb,
+                                 node_api_basic_finalize finalize_cb,
                                  void* finalize_hint,
                                  napi_value* result);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@@ -480,7 +485,7 @@ napi_get_dataview_info(napi_env env,
                        size_t* byte_offset);
 
 // version management
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);
 
 // Promises
@@ -504,7 +509,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env,
 
 // Memory management
 NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
-    node_api_nogc_env env, int64_t change_in_bytes, int64_t* adjusted_value);
+    node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value);
 
 #if NAPI_VERSION >= 5
 
@@ -526,7 +531,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_add_finalizer(napi_env env,
                    napi_value js_object,
                    void* finalize_data,
-                   node_api_nogc_finalize finalize_cb,
+                   node_api_basic_finalize finalize_cb,
                    void* finalize_hint,
                    napi_ref* result);
 
@@ -536,7 +541,7 @@ napi_add_finalizer(napi_env env,
 #define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
 
 NAPI_EXTERN napi_status NAPI_CDECL
-node_api_post_finalizer(node_api_nogc_env env,
+node_api_post_finalizer(node_api_basic_env env,
                         napi_finalize finalize_cb,
                         void* finalize_data,
                         void* finalize_hint);
@@ -581,13 +586,13 @@ napi_get_all_property_names(napi_env env,
 
 // Instance data
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_set_instance_data(node_api_nogc_env env,
+napi_set_instance_data(node_api_basic_env env,
                        void* data,
                        napi_finalize finalize_cb,
                        void* finalize_hint);
 
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env,
-                                                          void** data);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_instance_data(node_api_basic_env env, void** data);
 #endif  // NAPI_VERSION >= 6
 
 #if NAPI_VERSION >= 7

package/include/node/js_native_api_types.h

@@ -27,7 +27,7 @@ typedef struct napi_env__* napi_env;
 // meaning that they do not affect the state of the JS engine, and can
 // therefore be called synchronously from a finalizer that itself runs
 // synchronously during GC. Such APIs can receive either a `napi_env` or a
-// `node_api_nogc_env` as their first parameter, because we should be able to
+// `node_api_basic_env` as their first parameter, because we should be able to
 // also call them during normal, non-garbage-collecting operations, whereas
 // APIs that affect the state of the JS engine can only receive a `napi_env` as
 // their first parameter, because we must not call them during GC. In lieu of
@@ -37,19 +37,21 @@ typedef struct napi_env__* napi_env;
 // expecting a non-const value.
 //
 // In conjunction with appropriate CFLAGS to warn us if we're passing a const
-// (nogc) environment into an API that expects a non-const environment, and the
-// definition of nogc finalizer function pointer types below, which receive a
-// nogc environment as their first parameter, and can thus only call nogc APIs
-// (unless the user explicitly casts the environment), we achieve the ability
-// to ensure at compile time that we do not call APIs that affect the state of
-// the JS engine from a synchronous (nogc) finalizer.
+// (basic) environment into an API that expects a non-const environment, and
+// the definition of basic finalizer function pointer types below, which
+// receive a basic environment as their first parameter, and can thus only call
+// basic APIs (unless the user explicitly casts the environment), we achieve
+// the ability to ensure at compile time that we do not call APIs that affect
+// the state of the JS engine from a synchronous (basic) finalizer.
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
-     defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
 typedef struct napi_env__* node_api_nogc_env;
 #else
 typedef const struct napi_env__* node_api_nogc_env;
 #endif
+typedef node_api_nogc_env node_api_basic_env;
 
 typedef struct napi_value__* napi_value;
 typedef struct napi_ref__* napi_ref;
@@ -147,13 +149,15 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
 
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
-     defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
 typedef napi_finalize node_api_nogc_finalize;
 #else
 typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
                                                  void* finalize_data,
                                                  void* finalize_hint);
 #endif
+typedef node_api_nogc_finalize node_api_basic_finalize;
 
 typedef struct {
   // One of utf8name or name should be NULL.

package/include/node/node_api.h

@@ -141,10 +141,22 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external_buffer(napi_env env,
                             size_t length,
                             void* data,
-                            node_api_nogc_finalize finalize_cb,
+                            node_api_basic_finalize finalize_cb,
                             void* finalize_hint,
                             napi_value* result);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_CREATE_BUFFER_FROM_ARRAYBUFFER
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_buffer_from_arraybuffer(napi_env env,
+                                        napi_value arraybuffer,
+                                        size_t byte_offset,
+                                        size_t byte_length,
+                                        napi_value* result);
+#endif  // NAPI_EXPERIMENTAL
+
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env,
                                                            size_t length,
                                                            const void* data,
@@ -169,20 +181,20 @@ napi_create_async_work(napi_env env,
                        napi_async_work* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
                                                           napi_async_work work);
-NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env,
                                                          napi_async_work work);
-NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(node_api_nogc_env env,
-                                                          napi_async_work work);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_cancel_async_work(node_api_basic_env env, napi_async_work work);
 
 // version management
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_get_node_version(node_api_nogc_env env, const napi_node_version** version);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version(
+    node_api_basic_env env, const napi_node_version** version);
 
 #if NAPI_VERSION >= 2
 
 // Return the current libuv event loop for a given environment
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_get_uv_event_loop(node_api_nogc_env env, struct uv_loop_s** loop);
+napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop);
 
 #endif  // NAPI_VERSION >= 2
 
@@ -192,10 +204,10 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env,
                                                         napi_value err);
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook(
-    node_api_nogc_env env, napi_cleanup_hook fun, void* arg);
+    node_api_basic_env env, napi_cleanup_hook fun, void* arg);
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook(
-    node_api_nogc_env env, napi_cleanup_hook fun, void* arg);
+    node_api_basic_env env, napi_cleanup_hook fun, void* arg);
 
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_open_callback_scope(napi_env env,
@@ -239,17 +251,17 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
     napi_threadsafe_function func, napi_threadsafe_function_release_mode mode);
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(
-    node_api_nogc_env env, napi_threadsafe_function func);
+    node_api_basic_env env, napi_threadsafe_function func);
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(
-    node_api_nogc_env env, napi_threadsafe_function func);
+    node_api_basic_env env, napi_threadsafe_function func);
 
 #endif  // NAPI_VERSION >= 4
 
 #if NAPI_VERSION >= 8
 
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_add_async_cleanup_hook(node_api_nogc_env env,
+napi_add_async_cleanup_hook(node_api_basic_env env,
                             napi_async_cleanup_hook hook,
                             void* arg,
                             napi_async_cleanup_hook_handle* remove_handle);
@@ -262,7 +274,7 @@ napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle);
 #if NAPI_VERSION >= 9
 
 NAPI_EXTERN napi_status NAPI_CDECL
-node_api_get_module_file_name(node_api_nogc_env env, const char** result);
+node_api_get_module_file_name(node_api_basic_env env, const char** result);
 
 #endif  // NAPI_VERSION >= 9
 

package/include/node/uv/threadpool.h

@@ -33,7 +33,7 @@ struct uv__work {
   void (*work)(struct uv__work *w);
   void (*done)(struct uv__work *w, int status);
   struct uv_loop_s* loop;
-  void* wq[2];
+  struct uv__queue wq;
 };
 
 #endif

package/include/node/uv/unix.h

@@ -18,4 +18,8 @@ typedef pthread_cond_t uv_cond_t;
 
 #endif
 
+#define UV_HANDLE_PRIVATE_FIELDS                                              \
+  uv_handle_t* next_closing;                                                  \
+  unsigned int flags;                                                         \
+
 #endif /* UV_UNIX_H */

package/include/node/uv.h

@@ -3,13 +3,21 @@
 
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
-#include <stddef.h>
-#include "uv/unix.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#include <stddef.h>
+#include <stdint.h>
+
+/* Internal type, do not use. */
+struct uv__queue {
+  struct uv__queue* next;
+  struct uv__queue* prev;
+};
+
+#include "uv/unix.h"
+
 #define UV_EXTERN /* nothing */
 
 typedef enum {
@@ -29,6 +37,8 @@ typedef struct uv_work_s uv_work_t;
 typedef struct uv_handle_s uv_handle_t;
 typedef struct uv_async_s uv_async_t;
 
+typedef struct uv_metrics_s uv_metrics_t;
+
 typedef void (*uv_work_cb)(uv_work_t* req);
 typedef void (*uv_after_work_cb)(uv_work_t* req, int status);
 
@@ -40,10 +50,22 @@ struct uv_req_s {
   UV_REQ_FIELDS
 };
 
+typedef void* (*uv_malloc_func)(size_t size);
+typedef void* (*uv_realloc_func)(void* ptr, size_t size);
+typedef void* (*uv_calloc_func)(size_t count, size_t size);
+typedef void (*uv_free_func)(void* ptr);
+
 UV_EXTERN void uv_library_shutdown(void);
+
+UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func,
+                                   uv_realloc_func realloc_func,
+                                   uv_calloc_func calloc_func,
+                                   uv_free_func free_func);
+
 UV_EXTERN uv_loop_t* uv_default_loop(void);
 UV_EXTERN int uv_loop_init(uv_loop_t* loop);
 UV_EXTERN int uv_loop_close(uv_loop_t* loop);
+UV_EXTERN uint64_t uv_hrtime(void);
 UV_EXTERN void uv_sleep(unsigned int msec);
 
 UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value);
@@ -111,6 +133,12 @@ typedef void (*uv_async_cb)(uv_async_t* handle);
   uv_loop_t* loop;                                                            \
   uv_handle_type type;                                                        \
   uv_close_cb close_cb;                                                       \
+  struct uv__queue handle_queue;                                              \
+  union {                                                                     \
+    int fd;                                                                   \
+    void* reserved[4];                                                        \
+  } u;                                                                        \
+  UV_HANDLE_PRIVATE_FIELDS                                                    \
 
 struct uv_handle_s {
   UV_HANDLE_FIELDS
@@ -119,7 +147,7 @@ struct uv_handle_s {
 struct uv_async_s {
   UV_HANDLE_FIELDS
   uv_async_cb async_cb;
-  void* queue[2];
+  struct uv__queue queue;
   int pending;
 };
 
@@ -129,18 +157,33 @@ UV_EXTERN int uv_async_init(uv_loop_t*,
 UV_EXTERN int uv_async_send(uv_async_t* async);
 
 UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb);
+UV_EXTERN int uv_is_closing(const uv_handle_t* handle);
+
+struct uv_metrics_s {
+  uint64_t loop_count;
+  uint64_t events;
+  uint64_t events_waiting;
+  /* private */
+  uint64_t* reserved[13];
+};
+
+UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics);
+UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop);
 
 struct uv_loop_s {
   void* data;
+  unsigned int active_handles;
+  struct uv__queue handle_queue;
   union {
     void* unused;
     unsigned int count;
   } active_reqs;
-  void* wq[2];
+  void* internal_fields;
 
+  struct uv__queue wq;
   uv_mutex_t wq_mutex;
   uv_async_t wq_async;
-  void* async_handles[2];
+  struct uv__queue async_handles;
   void* em_queue;
 };
 

package/index.js

@@ -16,6 +16,7 @@ const sources = [
   path.join(__dirname, './src/uv/uv-common.c'),
   path.join(__dirname, './src/uv/threadpool.c'),
   path.join(__dirname, './src/uv/unix/loop.c'),
+  path.join(__dirname, './src/uv/unix/posix-hrtime.c'),
   path.join(__dirname, './src/uv/unix/thread.c'),
   path.join(__dirname, './src/uv/unix/async.c'),
   path.join(__dirname, './src/uv/unix/core.c')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,

package/src/async_cleanup_hook.c

@@ -101,7 +101,7 @@ _emnapi_ach_handle_delete(napi_async_cleanup_hook_handle handle) {
 }
 
 napi_status
-napi_add_async_cleanup_hook(napi_env env,
+napi_add_async_cleanup_hook(node_api_basic_env env,
                             napi_async_cleanup_hook hook,
                             void* arg,
                             napi_async_cleanup_hook_handle* remove_handle) {

package/src/async_work.c

@@ -198,7 +198,7 @@ napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
 #endif
 }
 
-napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
+napi_status napi_queue_async_work(node_api_basic_env env, napi_async_work work) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
   CHECK_ARG(env, work);
@@ -220,7 +220,7 @@ napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
     }                                                                   \
   } while (0)
 
-napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
+napi_status napi_cancel_async_work(node_api_basic_env env, napi_async_work work) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
   CHECK_ARG(env, work);

package/src/emnapi_internal.h

@@ -72,11 +72,11 @@ EXTERN_C_END
 
 EXTERN_C_START
 
-EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_nogc_env env,
+EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_basic_env env,
                                        napi_status error_code,
                                        uint32_t engine_error_code,
                                        void* engine_reserved);
-EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_nogc_env env);
+EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_basic_env env);
 
 #ifdef __EMSCRIPTEN__
 #if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT

package/src/js_native_api.c

@@ -35,8 +35,9 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_get_last_error_info(napi_env env,
                                         void** engine_reserved);
 
 napi_status napi_get_last_error_info(
-    napi_env env, const napi_extended_error_info** result) {
+    node_api_basic_env basic_env, const napi_extended_error_info** result) {
   static napi_extended_error_info last_error;
+  napi_env env = (napi_env) basic_env;
   CHECK_ENV(env);
   CHECK_ARG(env, result);
 

package/src/node_api.c

@@ -1,7 +1,7 @@
 #include "node_api.h"
 #include "emnapi_internal.h"
 
-#if EMNAPI_HAVE_THREADS
+#if EMNAPI_HAVE_THREADS && !defined(EMNAPI_DISABLE_UV)
 #include "uv.h"
 #endif
 
@@ -12,7 +12,7 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_get_node_version(uint32_t* major,
                                      uint32_t* patch);
 
 napi_status
-napi_get_node_version(napi_env env,
+napi_get_node_version(node_api_basic_env env,
                       const napi_node_version** version) {
   CHECK_ENV(env);
   CHECK_ARG(env, version);
@@ -29,9 +29,9 @@ napi_get_node_version(napi_env env,
   return napi_clear_last_error(env);
 }
 
-napi_status napi_get_uv_event_loop(napi_env env,
+napi_status napi_get_uv_event_loop(node_api_basic_env env,
                                    struct uv_loop_s** loop) {
-#if EMNAPI_HAVE_THREADS
+#if EMNAPI_HAVE_THREADS && !defined(EMNAPI_DISABLE_UV)
   CHECK_ENV(env);
   CHECK_ARG(env, loop);
   // Though this is fake libuv loop
@@ -44,7 +44,7 @@ napi_status napi_get_uv_event_loop(napi_env env,
 
 EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(napi_env env, char* buf, int len);
 
-napi_status node_api_get_module_file_name(napi_env env,
+napi_status node_api_get_module_file_name(node_api_basic_env env,
                                           const char** result) {
   CHECK_ENV(env);
   CHECK_ARG(env, result);