diff options
| -rw-r--r-- | src/javascript/jsc/bindings/bindings.zig | 19 | ||||
| -rw-r--r-- | src/napi/js_native_api.h | 458 | ||||
| -rw-r--r-- | src/napi/js_native_api_types.h | 156 | ||||
| -rw-r--r-- | src/napi/napi.zig | 497 | ||||
| -rw-r--r-- | src/napi/node_api.h | 242 | ||||
| -rw-r--r-- | src/napi/node_api_types.h | 47 |
6 files changed, 1416 insertions, 3 deletions
diff --git a/src/javascript/jsc/bindings/bindings.zig b/src/javascript/jsc/bindings/bindings.zig index 5c1d2c0cc..0738fe4bf 100644 --- a/src/javascript/jsc/bindings/bindings.zig +++ b/src/javascript/jsc/bindings/bindings.zig @@ -170,6 +170,10 @@ pub const ZigString = extern struct { return @ptrCast([*]align(1) const u16, untagged(this.ptr))[0..this.len]; } + pub inline fn utf16SliceAligned(this: *const ZigString) []const u16 { + return @ptrCast([*]const u16, @alignCast(@alignOf(u16), untagged(this.ptr)))[0..this.len]; + } + pub inline fn isEmpty(this: *const ZigString) bool { return this.len == 0; } @@ -205,6 +209,12 @@ pub const ZigString = extern struct { return JSC.JSValue.fromRef(slice_).getZigString(ctx.ptr()); } + pub fn from16(slice_: [*]const u16, len: usize) ZigString { + var str = init(@ptrCast([*]const u8, slice_)[0..len]); + str.markUTF16(); + return str; + } + pub fn toBase64DataURL(this: ZigString, allocator: std.mem.Allocator) ![]const u8 { const slice_ = this.slice(); const size = std.base64.standard.Encoder.calcSize(slice_.len); @@ -2003,6 +2013,7 @@ pub const String = extern struct { }; pub const JSValue = enum(u64) { + @"undefined" = 0xa, _, pub const shim = Shimmer("JSC", "JSValue", @This()); @@ -2230,6 +2241,7 @@ pub const JSValue = enum(u64) { u52 => @truncate(u52, this.to(u64)), u64 => @intCast(u64, @maximum(toInt64(this), 0)), + f64 => asNUmber(this), u8 => @truncate(u8, toU32(this)), i16 => @truncate(i16, toInt32(this)), @@ -2238,6 +2250,7 @@ pub const JSValue = enum(u64) { // TODO: BigInt64 i64 => @as(i64, toInt32(this)), + bool => this.toBoolean(), else => @compileError("Not implemented yet"), }; } @@ -2374,8 +2387,8 @@ pub const JSValue = enum(u64) { pub fn jsNull() JSValue { return cppFn("jsNull", .{}); } - pub fn jsUndefined() JSValue { - return cppFn("jsUndefined", .{}); + pub inline fn jsUndefined() JSValue { + return JSValue.@"undefined"; } pub fn jsTDZValue() JSValue { return cppFn("jsTDZValue", .{}); @@ -2603,7 +2616,7 @@ pub const JSValue = enum(u64) { } // On exception, this returns null, to make exception checks faster. - pub fn toStringOrNull(this: JSValue, globalThis: *JSGlobalObject) *JSString { + pub fn toStringOrNull(this: JSValue, globalThis: *JSGlobalObject) ?*JSString { return cppFn("toStringOrNull", .{ this, globalThis }); } pub fn toPropertyKey(this: JSValue, globalThis: *JSGlobalObject) Identifier { diff --git a/src/napi/js_native_api.h b/src/napi/js_native_api.h new file mode 100644 index 000000000..40db9dec2 --- /dev/null +++ b/src/napi/js_native_api.h @@ -0,0 +1,458 @@ +#ifndef SRC_JS_NATIVE_API_H_ +#define SRC_JS_NATIVE_API_H_ + +// This file needs to be compatible with C compilers. +#include <stdbool.h> // NOLINT(modernize-deprecated-headers) +#include <stddef.h> // NOLINT(modernize-deprecated-headers) + +// Use INT_MAX, this should only be consumed by the pre-processor anyway. +#define NAPI_VERSION_EXPERIMENTAL 2147483647 +#ifndef NAPI_VERSION +#ifdef NAPI_EXPERIMENTAL +#define NAPI_VERSION NAPI_VERSION_EXPERIMENTAL +#else +// The baseline version for N-API. +// The NAPI_VERSION controls which version will be used by default when +// compilling a native addon. If the addon developer specifically wants to use +// functions available in a new version of N-API that is not yet ported in all +// LTS versions, they can set NAPI_VERSION knowing that they have specifically +// depended on that version. +#define NAPI_VERSION 8 +#endif +#endif + +#include "js_native_api_types.h" + +// If you need __declspec(dllimport), either include <node_api.h> instead, or +// define NAPI_EXTERN as __declspec(dllimport) on the compiler's command line. +#ifndef NAPI_EXTERN +#ifdef _WIN32 +#define NAPI_EXTERN __declspec(dllexport) +#elif defined(__wasm32__) +#define NAPI_EXTERN \ + __attribute__((visibility("default"))) \ + __attribute__((__import_module__("napi"))) +#else +#define NAPI_EXTERN __attribute__((visibility("default"))) +#endif +#endif + +#define NAPI_AUTO_LENGTH SIZE_MAX + +#ifdef __cplusplus +#define EXTERN_C_START extern "C" { +#define EXTERN_C_END } +#else +#define EXTERN_C_START +#define EXTERN_C_END +#endif + +EXTERN_C_START + +NAPI_EXTERN napi_status +napi_get_last_error_info(napi_env env, const napi_extended_error_info **result); + +// Getters for defined singletons +NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value *result); +NAPI_EXTERN napi_status napi_get_null(napi_env env, napi_value *result); +NAPI_EXTERN napi_status napi_get_global(napi_env env, napi_value *result); +NAPI_EXTERN napi_status napi_get_boolean(napi_env env, bool value, + napi_value *result); + +// Methods to create Primitive types/Objects +NAPI_EXTERN napi_status napi_create_object(napi_env env, napi_value *result); +NAPI_EXTERN napi_status napi_create_array(napi_env env, napi_value *result); +NAPI_EXTERN napi_status napi_create_array_with_length(napi_env env, + size_t length, + napi_value *result); +NAPI_EXTERN napi_status napi_create_double(napi_env env, double value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_int32(napi_env env, int32_t value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_uint32(napi_env env, uint32_t value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_int64(napi_env env, int64_t value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env, const char *str, + size_t length, + napi_value *result); +NAPI_EXTERN napi_status napi_create_string_utf8(napi_env env, const char *str, + size_t length, + napi_value *result); +NAPI_EXTERN napi_status napi_create_string_utf16(napi_env env, + const char16_t *str, + size_t length, + napi_value *result); +NAPI_EXTERN napi_status napi_create_symbol(napi_env env, napi_value description, + napi_value *result); +#ifdef NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status node_api_symbol_for(napi_env env, + const char *utf8description, + size_t length, napi_value *result); +#endif // NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status napi_create_function(napi_env env, const char *utf8name, + size_t length, napi_callback cb, + void *data, napi_value *result); +NAPI_EXTERN napi_status napi_create_error(napi_env env, napi_value code, + napi_value msg, napi_value *result); +NAPI_EXTERN napi_status napi_create_type_error(napi_env env, napi_value code, + napi_value msg, + napi_value *result); +NAPI_EXTERN napi_status napi_create_range_error(napi_env env, napi_value code, + napi_value msg, + napi_value *result); +#ifdef NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status node_api_create_syntax_error(napi_env env, + napi_value code, + napi_value msg, + napi_value *result); +#endif // NAPI_EXPERIMENTAL + +// Methods to get the native napi_value from Primitive type +NAPI_EXTERN napi_status napi_typeof(napi_env env, napi_value value, + napi_valuetype *result); +NAPI_EXTERN napi_status napi_get_value_double(napi_env env, napi_value value, + double *result); +NAPI_EXTERN napi_status napi_get_value_int32(napi_env env, napi_value value, + int32_t *result); +NAPI_EXTERN napi_status napi_get_value_uint32(napi_env env, napi_value value, + uint32_t *result); +NAPI_EXTERN napi_status napi_get_value_int64(napi_env env, napi_value value, + int64_t *result); +NAPI_EXTERN napi_status napi_get_value_bool(napi_env env, napi_value value, + bool *result); + +// Copies LATIN-1 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env, + napi_value value, + char *buf, size_t bufsize, + size_t *result); + +// Copies UTF-8 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status napi_get_value_string_utf8(napi_env env, + napi_value value, char *buf, + size_t bufsize, + size_t *result); + +// Copies UTF-16 encoded bytes from a string into a buffer. +NAPI_EXTERN napi_status napi_get_value_string_utf16(napi_env env, + napi_value value, + char16_t *buf, + size_t bufsize, + size_t *result); + +// Methods to coerce values +// These APIs may execute user scripts +NAPI_EXTERN napi_status napi_coerce_to_bool(napi_env env, napi_value value, + napi_value *result); +NAPI_EXTERN napi_status napi_coerce_to_number(napi_env env, napi_value value, + napi_value *result); +NAPI_EXTERN napi_status napi_coerce_to_object(napi_env env, napi_value value, + napi_value *result); +NAPI_EXTERN napi_status napi_coerce_to_string(napi_env env, napi_value value, + napi_value *result); + +// Methods to work with Objects +NAPI_EXTERN napi_status napi_get_prototype(napi_env env, napi_value object, + napi_value *result); +NAPI_EXTERN napi_status napi_get_property_names(napi_env env, napi_value object, + napi_value *result); +NAPI_EXTERN napi_status napi_set_property(napi_env env, napi_value object, + napi_value key, napi_value value); +NAPI_EXTERN napi_status napi_has_property(napi_env env, napi_value object, + napi_value key, bool *result); +NAPI_EXTERN napi_status napi_get_property(napi_env env, napi_value object, + napi_value key, napi_value *result); +NAPI_EXTERN napi_status napi_delete_property(napi_env env, napi_value object, + napi_value key, bool *result); +NAPI_EXTERN napi_status napi_has_own_property(napi_env env, napi_value object, + napi_value key, bool *result); +NAPI_EXTERN napi_status napi_set_named_property(napi_env env, napi_value object, + const char *utf8name, + napi_value value); +NAPI_EXTERN napi_status napi_has_named_property(napi_env env, napi_value object, + const char *utf8name, + bool *result); +NAPI_EXTERN napi_status napi_get_named_property(napi_env env, napi_value object, + const char *utf8name, + napi_value *result); +NAPI_EXTERN napi_status napi_set_element(napi_env env, napi_value object, + uint32_t index, napi_value value); +NAPI_EXTERN napi_status napi_has_element(napi_env env, napi_value object, + uint32_t index, bool *result); +NAPI_EXTERN napi_status napi_get_element(napi_env env, napi_value object, + uint32_t index, napi_value *result); +NAPI_EXTERN napi_status napi_delete_element(napi_env env, napi_value object, + uint32_t index, bool *result); +NAPI_EXTERN napi_status +napi_define_properties(napi_env env, napi_value object, size_t property_count, + const napi_property_descriptor *properties); + +// Methods to work with Arrays +NAPI_EXTERN napi_status napi_is_array(napi_env env, napi_value value, + bool *result); +NAPI_EXTERN napi_status napi_get_array_length(napi_env env, napi_value value, + uint32_t *result); + +// Methods to compare values +NAPI_EXTERN napi_status napi_strict_equals(napi_env env, napi_value lhs, + napi_value rhs, bool *result); + +// Methods to work with Functions +NAPI_EXTERN napi_status napi_call_function(napi_env env, napi_value recv, + napi_value func, size_t argc, + const napi_value *argv, + napi_value *result); +NAPI_EXTERN napi_status napi_new_instance(napi_env env, napi_value constructor, + size_t argc, const napi_value *argv, + napi_value *result); +NAPI_EXTERN napi_status napi_instanceof(napi_env env, napi_value object, + napi_value constructor, bool *result); + +// Methods to work with napi_callbacks + +// Gets all callback info in a single call. (Ugly, but faster.) +NAPI_EXTERN napi_status napi_get_cb_info( + napi_env env, // [in] NAPI environment handle + napi_callback_info cbinfo, // [in] Opaque callback-info handle + size_t *argc, // [in-out] Specifies the size of the provided argv array + // and receives the actual count of args. + napi_value *argv, // [out] Array of values + napi_value *this_arg, // [out] Receives the JS 'this' arg for the call + void **data); // [out] Receives the data pointer for the callback. + +NAPI_EXTERN napi_status napi_get_new_target(napi_env env, + napi_callback_info cbinfo, + napi_value *result); +NAPI_EXTERN napi_status napi_define_class( + napi_env env, const char *utf8name, size_t length, + napi_callback constructor, void *data, size_t property_count, + const napi_property_descriptor *properties, napi_value *result); + +// Methods to work with external data objects +NAPI_EXTERN napi_status napi_wrap(napi_env env, napi_value js_object, + void *native_object, + napi_finalize finalize_cb, + void *finalize_hint, napi_ref *result); +NAPI_EXTERN napi_status napi_unwrap(napi_env env, napi_value js_object, + void **result); +NAPI_EXTERN napi_status napi_remove_wrap(napi_env env, napi_value js_object, + void **result); +NAPI_EXTERN napi_status napi_create_external(napi_env env, void *data, + napi_finalize finalize_cb, + void *finalize_hint, + napi_value *result); +NAPI_EXTERN napi_status napi_get_value_external(napi_env env, napi_value value, + void **result); + +// Methods to control object lifespan + +// Set initial_refcount to 0 for a weak reference, >0 for a strong reference. +NAPI_EXTERN napi_status napi_create_reference(napi_env env, napi_value value, + uint32_t initial_refcount, + napi_ref *result); + +// Deletes a reference. The referenced value is released, and may +// be GC'd unless there are other references to it. +NAPI_EXTERN napi_status napi_delete_reference(napi_env env, napi_ref ref); + +// Increments the reference count, optionally returning the resulting count. +// After this call the reference will be a strong reference because its +// refcount is >0, and the referenced object is effectively "pinned". +// Calling this when the refcount is 0 and the object is unavailable +// results in an error. +NAPI_EXTERN napi_status napi_reference_ref(napi_env env, napi_ref ref, + uint32_t *result); + +// Decrements the reference count, optionally returning the resulting count. +// If the result is 0 the reference is now weak and the object may be GC'd +// at any time if there are no other references. Calling this when the +// refcount is already 0 results in an error. +NAPI_EXTERN napi_status napi_reference_unref(napi_env env, napi_ref ref, + uint32_t *result); + +// Attempts to get a referenced value. If the reference is weak, +// the value might no longer be available, in that case the call +// is still successful but the result is NULL. +NAPI_EXTERN napi_status napi_get_reference_value(napi_env env, napi_ref ref, + napi_value *result); + +NAPI_EXTERN napi_status napi_open_handle_scope(napi_env env, + napi_handle_scope *result); +NAPI_EXTERN napi_status napi_close_handle_scope(napi_env env, + napi_handle_scope scope); +NAPI_EXTERN napi_status napi_open_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope *result); +NAPI_EXTERN napi_status napi_close_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope scope); + +NAPI_EXTERN napi_status napi_escape_handle(napi_env env, + napi_escapable_handle_scope scope, + napi_value escapee, + napi_value *result); + +// Methods to support error handling +NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error); +NAPI_EXTERN napi_status napi_throw_error(napi_env env, const char *code, + const char *msg); +NAPI_EXTERN napi_status napi_throw_type_error(napi_env env, const char *code, + const char *msg); +NAPI_EXTERN napi_status napi_throw_range_error(napi_env env, const char *code, + const char *msg); +#ifdef NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status node_api_throw_syntax_error(napi_env env, + const char *code, + const char *msg); +#endif // NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status napi_is_error(napi_env env, napi_value value, + bool *result); + +// Methods to support catching exceptions +NAPI_EXTERN napi_status napi_is_exception_pending(napi_env env, bool *result); +NAPI_EXTERN napi_status napi_get_and_clear_last_exception(napi_env env, + napi_value *result); + +// Methods to work with array buffers and typed arrays +NAPI_EXTERN napi_status napi_is_arraybuffer(napi_env env, napi_value value, + bool *result); +NAPI_EXTERN napi_status napi_create_arraybuffer(napi_env env, + size_t byte_length, void **data, + napi_value *result); +NAPI_EXTERN napi_status napi_create_external_arraybuffer( + napi_env env, void *external_data, size_t byte_length, + napi_finalize finalize_cb, void *finalize_hint, napi_value *result); +NAPI_EXTERN napi_status napi_get_arraybuffer_info(napi_env env, + napi_value arraybuffer, + void **data, + size_t *byte_length); +NAPI_EXTERN napi_status napi_is_typedarray(napi_env env, napi_value value, + bool *result); +NAPI_EXTERN napi_status napi_create_typedarray( + napi_env env, napi_typedarray_type type, size_t length, + napi_value arraybuffer, size_t byte_offset, napi_value *result); +NAPI_EXTERN napi_status napi_get_typedarray_info( + napi_env env, napi_value typedarray, napi_typedarray_type *type, + size_t *length, void **data, napi_value *arraybuffer, size_t *byte_offset); + +NAPI_EXTERN napi_status napi_create_dataview(napi_env env, size_t length, + napi_value arraybuffer, + size_t byte_offset, + napi_value *result); +NAPI_EXTERN napi_status napi_is_dataview(napi_env env, napi_value value, + bool *result); +NAPI_EXTERN napi_status napi_get_dataview_info(napi_env env, + napi_value dataview, + size_t *bytelength, void **data, + napi_value *arraybuffer, + size_t *byte_offset); + +// version management +NAPI_EXTERN napi_status napi_get_version(napi_env env, uint32_t *result); + +// Promises +NAPI_EXTERN napi_status napi_create_promise(napi_env env, + napi_deferred *deferred, + napi_value *promise); +NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env, + napi_deferred deferred, + napi_value resolution); +NAPI_EXTERN napi_status napi_reject_deferred(napi_env env, + napi_deferred deferred, + napi_value rejection); +NAPI_EXTERN napi_status napi_is_promise(napi_env env, napi_value value, + bool *is_promise); + +// Running a script +NAPI_EXTERN napi_status napi_run_script(napi_env env, napi_value script, + napi_value *result); + +// Memory management +NAPI_EXTERN napi_status napi_adjust_external_memory(napi_env env, + int64_t change_in_bytes, + int64_t *adjusted_value); + +#if NAPI_VERSION >= 5 + +// Dates +NAPI_EXTERN napi_status napi_create_date(napi_env env, double time, + napi_value *result); + +NAPI_EXTERN napi_status napi_is_date(napi_env env, napi_value value, + bool *is_date); + +NAPI_EXTERN napi_status napi_get_date_value(napi_env env, napi_value value, + double *result); + +// Add finalizer for pointer +NAPI_EXTERN napi_status napi_add_finalizer(napi_env env, napi_value js_object, + void *native_object, + napi_finalize finalize_cb, + void *finalize_hint, + napi_ref *result); + +#endif // NAPI_VERSION >= 5 + +#if NAPI_VERSION >= 6 + +// BigInt +NAPI_EXTERN napi_status napi_create_bigint_int64(napi_env env, int64_t value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, + napi_value *result); +NAPI_EXTERN napi_status napi_create_bigint_words(napi_env env, int sign_bit, + size_t word_count, + const uint64_t *words, + napi_value *result); +NAPI_EXTERN napi_status napi_get_value_bigint_int64(napi_env env, + napi_value value, + int64_t *result, + bool *lossless); +NAPI_EXTERN napi_status napi_get_value_bigint_uint64(napi_env env, + napi_value value, + uint64_t *result, + bool *lossless); +NAPI_EXTERN napi_status napi_get_value_bigint_words(napi_env env, + napi_value value, + int *sign_bit, + size_t *word_count, + uint64_t *words); + +// Object +NAPI_EXTERN napi_status napi_get_all_property_names( + napi_env env, napi_value object, napi_key_collection_mode key_mode, + napi_key_filter key_filter, napi_key_conversion key_conversion, + napi_value *result); + +// Instance data +NAPI_EXTERN napi_status napi_set_instance_data(napi_env env, void *data, + napi_finalize finalize_cb, + void *finalize_hint); + +NAPI_EXTERN napi_status napi_get_instance_data(napi_env env, void **data); +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 7 +// ArrayBuffer detaching +NAPI_EXTERN napi_status napi_detach_arraybuffer(napi_env env, + napi_value arraybuffer); + +NAPI_EXTERN napi_status napi_is_detached_arraybuffer(napi_env env, + napi_value value, + bool *result); +#endif // NAPI_VERSION >= 7 + +#if NAPI_VERSION >= 8 +// Type tagging +NAPI_EXTERN napi_status napi_type_tag_object(napi_env env, napi_value value, + const napi_type_tag *type_tag); + +NAPI_EXTERN napi_status +napi_check_object_type_tag(napi_env env, napi_value value, + const napi_type_tag *type_tag, bool *result); +NAPI_EXTERN napi_status napi_object_freeze(napi_env env, napi_value object); +NAPI_EXTERN napi_status napi_object_seal(napi_env env, napi_value object); +#endif // NAPI_VERSION >= 8 + +EXTERN_C_END + +#endif // SRC_JS_NATIVE_API_H_ diff --git a/src/napi/js_native_api_types.h b/src/napi/js_native_api_types.h new file mode 100644 index 000000000..2cfe45c57 --- /dev/null +++ b/src/napi/js_native_api_types.h @@ -0,0 +1,156 @@ +#ifndef SRC_JS_NATIVE_API_TYPES_H_ +#define SRC_JS_NATIVE_API_TYPES_H_ + +// This file needs to be compatible with C compilers. +// This is a public include file, and these includes have essentially +// became part of it's API. +#include <stddef.h> // NOLINT(modernize-deprecated-headers) +#include <stdint.h> // NOLINT(modernize-deprecated-headers) + +#if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900) +typedef uint16_t char16_t; +#endif + +// JSVM API types are all opaque pointers for ABI stability +// typedef undefined structs instead of void* for compile time type safety +typedef struct napi_env__ *napi_env; +typedef struct napi_value__ *napi_value; +typedef struct napi_ref__ *napi_ref; +typedef struct napi_handle_scope__ *napi_handle_scope; +typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope; +typedef struct napi_callback_info__ *napi_callback_info; +typedef struct napi_deferred__ *napi_deferred; + +typedef enum { + napi_default = 0, + napi_writable = 1 << 0, + napi_enumerable = 1 << 1, + napi_configurable = 1 << 2, + + // Used with napi_define_class to distinguish static properties + // from instance properties. Ignored by napi_define_properties. + napi_static = 1 << 10, + +#if NAPI_VERSION >= 8 + // Default for class methods. + napi_default_method = napi_writable | napi_configurable, + + // Default for object properties, like in JS obj[prop]. + napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable, +#endif // NAPI_VERSION >= 8 +} napi_property_attributes; + +typedef enum { + // ES6 types (corresponds to typeof) + napi_undefined, + napi_null, + napi_boolean, + napi_number, + napi_string, + napi_symbol, + napi_object, + napi_function, + napi_external, + napi_bigint, +} napi_valuetype; + +typedef enum { + napi_int8_array, + napi_uint8_array, + napi_uint8_clamped_array, + napi_int16_array, + napi_uint16_array, + napi_int32_array, + napi_uint32_array, + napi_float32_array, + napi_float64_array, + napi_bigint64_array, + napi_biguint64_array, +} napi_typedarray_type; + +typedef enum { + napi_ok, + napi_invalid_arg, + napi_object_expected, + napi_string_expected, + napi_name_expected, + napi_function_expected, + napi_number_expected, + napi_boolean_expected, + napi_array_expected, + napi_generic_failure, + napi_pending_exception, + napi_cancelled, + napi_escape_called_twice, + napi_handle_scope_mismatch, + napi_callback_scope_mismatch, + napi_queue_full, + napi_closing, + napi_bigint_expected, + napi_date_expected, + napi_arraybuffer_expected, + napi_detachable_arraybuffer_expected, + napi_would_deadlock // unused +} napi_status; +// Note: when adding a new enum value to `napi_status`, please also update +// * `const int last_status` in the definition of `napi_get_last_error_info()' +// in file js_native_api_v8.cc. +// * `const char* error_messages[]` in file js_native_api_v8.cc with a brief +// message explaining the error. +// * the definition of `napi_status` in doc/api/n-api.md to reflect the newly +// added value(s). + +typedef napi_value (*napi_callback)(napi_env env, napi_callback_info info); +typedef void (*napi_finalize)(napi_env env, void *finalize_data, + void *finalize_hint); + +typedef struct { + // One of utf8name or name should be NULL. + const char *utf8name; + napi_value name; + + napi_callback method; + napi_callback getter; + napi_callback setter; + napi_value value; + + napi_property_attributes attributes; + void *data; +} napi_property_descriptor; + +typedef struct { + const char *error_message; + void *engine_reserved; + uint32_t engine_error_code; + napi_status error_code; +} napi_extended_error_info; + +#if NAPI_VERSION >= 6 +typedef enum { + napi_key_include_prototypes, + napi_key_own_only +} napi_key_collection_mode; + +typedef enum { + napi_key_all_properties = 0, + napi_key_writable = 1, + napi_key_enumerable = 1 << 1, + napi_key_configurable = 1 << 2, + napi_key_skip_strings = 1 << 3, + napi_key_skip_symbols = 1 << 4 +} napi_key_filter; + +typedef enum { + napi_key_keep_numbers, + napi_key_numbers_to_strings +} napi_key_conversion; +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 8 +typedef struct { + uint64_t lower; + uint64_t upper; +} napi_type_tag; +#endif // NAPI_VERSION >= 8 + +#endif // SRC_JS_NATIVE_API_TYPES_H_ diff --git a/src/napi/napi.zig b/src/napi/napi.zig new file mode 100644 index 000000000..c95a75fb8 --- /dev/null +++ b/src/napi/napi.zig @@ -0,0 +1,497 @@ +const std = @import("std"); +const JSC = @import("javascript_core"); +const strings = @import("strings"); +const JSValue = JSC.JSValue; +const ZigString = JSC.ZigString; +const TODO_EXCEPTION: JSC.C.ExceptionRef = null; + +pub const napi_env = *JSC.JSGlobalObject; +pub const napi_ref = struct_napi_ref__; +pub const napi_handle_scope = struct_napi_handle_scope__; +pub const napi_escapable_handle_scope = struct_napi_escapable_handle_scope__; +pub const napi_callback_info = struct_napi_callback_info__; +pub const napi_deferred = struct_napi_deferred__; +pub const napi_callback_scope = struct_napi_callback_scope__; +pub const napi_async_context = struct_napi_async_context__; +pub const napi_async_work = struct_napi_async_work__; +pub const napi_threadsafe_function = struct_napi_threadsafe_function__; +pub const napi_async_cleanup_hook_handle = struct_napi_async_cleanup_hook_handle__; +pub const uv_loop_s = struct_uv_loop_s; + +pub const napi_value = JSC.JSValue; +pub const struct_napi_ref__ = opaque {}; +pub const struct_napi_handle_scope__ = opaque {}; +pub const struct_napi_escapable_handle_scope__ = opaque {}; +pub const struct_napi_callback_info__ = opaque {}; +pub const struct_napi_deferred__ = opaque {}; + +const char16_t = u16; +pub const napi_default: c_int = 0; +pub const napi_writable: c_int = 1; +pub const napi_enumerable: c_int = 2; +pub const napi_configurable: c_int = 4; +pub const napi_static: c_int = 1024; +pub const napi_default_method: c_int = 5; +pub const napi_default_jsproperty: c_int = 7; +pub const napi_property_attributes = c_uint; +pub const napi_valuetype = enum(c_uint) { + @"undefined" = 0, + @"null" = 1, + @"boolean" = 2, + @"number" = 3, + @"string" = 4, + @"symbol" = 5, + @"object" = 6, + @"function" = 7, + @"external" = 8, + @"bigint" = 9, +}; +pub const napi_typedarray_type = enum(c_uint) { + int8_array = 0, + uint8_array = 1, + uint8_clamped_array = 2, + int16_array = 3, + uint16_array = 4, + int32_array = 5, + uint32_array = 6, + float32_array = 7, + float64_array = 8, + bigint64_array = 9, + biguint64_array = 10, +}; +pub const napi_status = enum(c_uint) { + ok = 0, + invalid_arg = 1, + object_expected = 2, + string_expected = 3, + name_expected = 4, + function_expected = 5, + number_expected = 6, + boolean_expected = 7, + array_expected = 8, + generic_failure = 9, + pending_exception = 10, + cancelled = 11, + escape_called_twice = 12, + handle_scope_mismatch = 13, + callback_scope_mismatch = 14, + queue_full = 15, + closing = 16, + bigint_expected = 17, + date_expected = 18, + arraybuffer_expected = 19, + detachable_arraybuffer_expected = 20, + would_deadlock = 21, +}; +pub const napi_callback = ?fn (napi_env, napi_callback_info) callconv(.C) napi_value; +pub const napi_finalize = ?fn (napi_env, ?*anyopaque, ?*anyopaque) callconv(.C) void; +pub const napi_property_descriptor = extern struct { + utf8name: [*c]const u8, + name: napi_value, + method: napi_callback, + getter: napi_callback, + setter: napi_callback, + value: napi_value, + attributes: napi_property_attributes, + data: ?*anyopaque, +}; +pub const napi_extended_error_info = extern struct { + error_message: [*c]const u8, + engine_reserved: ?*anyopaque, + engine_error_code: u32, + error_code: napi_status, +}; +pub const napi_key_include_prototypes: c_int = 0; +pub const napi_key_own_only: c_int = 1; +pub const napi_key_collection_mode = c_uint; +pub const napi_key_all_properties: c_int = 0; +pub const napi_key_writable: c_int = 1; +pub const napi_key_enumerable: c_int = 2; +pub const napi_key_configurable: c_int = 4; +pub const napi_key_skip_strings: c_int = 8; +pub const napi_key_skip_symbols: c_int = 16; +pub const napi_key_filter = c_uint; +pub const napi_key_keep_numbers: c_int = 0; +pub const napi_key_numbers_to_strings: c_int = 1; +pub const napi_key_conversion = c_uint; +pub const napi_type_tag = extern struct { + lower: u64, + upper: u64, +}; +pub extern fn napi_get_last_error_info(env: napi_env, result: [*c][*c]const napi_extended_error_info) napi_status; +pub export fn napi_get_undefined(_: napi_env, result: *napi_value) napi_status { + result.* = JSValue.jsUndefined(); + return .ok; +} +pub export fn napi_get_null(_: napi_env, result: *napi_value) napi_status { + result.* = JSValue.jsNull(); + return .ok; +} +pub extern fn napi_get_global(env: napi_env, result: *napi_value) napi_status; +pub export fn napi_get_boolean(_: napi_env, value: bool, result: *napi_value) napi_status { + result.* = JSValue.jsBoolean(value); + return .ok; +} +pub export fn napi_create_object(env: napi_env, result: *napi_value) napi_status { + result.* = JSValue.c(JSC.C.JSObjectMake(env.ref(), null, null)); + return .ok; +} +pub export fn napi_create_array(env: napi_env, result: *napi_value) napi_status { + result.* = JSValue.c(JSC.C.JSObjectMakeArray(env.ref(), 0, null, null)); + return .ok; +} +const prefilled_undefined_args_array: [128]JSC.JSValue = brk: { + var args: [128]JSC.JSValue = undefined; + for (args) |_, i| { + args[i] = JSValue.jsUndefined(); + } + break :brk args; +}; +pub export fn napi_create_array_with_length(env: napi_env, length: usize, result: *napi_value) napi_status { + if (length < prefilled_undefined_args_array.len) { + result.* = JSValue.c(JSC.C.JSObjectMakeArray(env.ref(), length, @ptrCast([*]const JSC.C.JSValueRef, &prefilled_undefined_args_array[0..length]), null)); + return .ok; + } + + const allocator = JSC.VirtualMachine.vm.allocator; + var undefined_args = allocator.alloc(JSC.C.JSValueRef, length) catch return .generic_failure; + defer allocator.free(undefined_args); + for (undefined_args) |_, i| { + undefined_args[i] = JSValue.jsUndefined().asObjectRef(); + } + result.* = JSValue.c(JSC.C.JSObjectMakeArray(env.ptr(), length, undefined_args.ptr, null)); + + return .ok; +} +pub export fn napi_create_double(_: napi_env, value: f64, result: *napi_value) napi_status { + result.* = JSValue.jsNumber(value); + return .ok; +} +pub export fn napi_create_int32(_: napi_env, value: i32, result: *napi_value) napi_status { + result.* = JSValue.jsNumber(value); + return .ok; +} +pub export fn napi_create_uint32(_: napi_env, value: u32, result: *napi_value) napi_status { + result.* = JSValue.jsNumber(value); + return .ok; +} +pub export fn napi_create_int64(_: napi_env, value: i64, result: *napi_value) napi_status { + result.* = JSValue.jsNumber(value); + return .ok; +} +pub export fn napi_create_string_latin1(env: napi_env, str: [*]const u8, length: usize, result: *napi_value) napi_status { + var len = length; + if (NAPI_AUTO_LENGTH == length) { + len = std.mem.sliceTo(str, 0).len; + } + result.* = JSC.ZigString.init(str[0..len]).toValueGC(env); + return .ok; +} +pub export fn napi_create_string_utf8(env: napi_env, str: [*]const u8, length: usize, result: *napi_value) napi_status { + var len = length; + if (NAPI_AUTO_LENGTH == length) { + len = std.mem.sliceTo(str, 0).len; + } + result.* = JSC.ZigString.init(str[0..len]).withEncoding().toValueGC(env); + return .ok; +} +pub export fn napi_create_string_utf16(env: napi_env, str: [*]const char16_t, length: usize, result: *napi_value) napi_status { + var len = length; + if (NAPI_AUTO_LENGTH == length) { + len = std.mem.sliceTo(str, 0).len; + } + result.* = JSC.ZigString.from16(str, len, env).toValueGC(env); + return .ok; +} +pub export fn napi_create_symbol(env: napi_env, description: napi_value, result: *napi_value) napi_status { + var string_ref = JSC.C.JSValueToStringCopy(env, description, null); + defer JSC.C.JSStringRelease(string_ref); + result.* = JSValue.c(JSC.C.JSValueMakeSymbol(env, string_ref)); + return .ok; +} +// const wrapped_callback_function_class_def = JSC.C.JSClassDefinition{ +// .version = 0, +// .attributes = JSC.C.JSClassAttributes.kJSClassAttributeNone, +// .className = "", +// .parentClass = null, +// .staticValues = null, +// .staticFunctions = null, +// .initialize = null, +// .finalize = null, +// .hasProperty = null, +// .getProperty = null, +// .setProperty = null, +// .deleteProperty = null, +// .getPropertyNames = null, +// .callAsFunction = call_wrapped_callback_function, +// .callAsConstructor = null, +// .hasInstance = null, +// .convertToType = null, +// }; + +// pub fn call_wrapped_callback_function( +// ctx: JSC.C.JSContextRef, +// function: JSC.C.JSObjectRef, +// thisObject: JSC.C.JSObjectRef, +// argumentCount: usize, +// arguments: [*c]const JSC.C.JSValueRef, +// exception: JSC.C.ExceptionRef, +// ) callconv(.C) JSC.C.JSValueRef { +// var private = JSC.C.JSObjectGetPrivate(function); + +// } + +// pub fn getWrappedCallbackFunctionClass(env: napi_env) JSC.C.JSClassRef {} +// pub export fn napi_create_function(env: napi_env, utf8name: [*c]const u8, length: usize, cb: napi_callback, data: ?*anyopaque, result: *napi_value) napi_status { +// // JSC.C.JSObjectMakeFunctionWithCallback(ctx: JSContextRef, name: JSStringRef, callAsFunction: JSObjectCallAsFunctionCallback) +// } +pub export fn napi_create_error(env: napi_env, code: napi_value, msg: napi_value, result: *napi_value) napi_status { + const system_error = JSC.SystemError{ + .code = if (!code.isEmptyOrUndefinedOrNull()) code.getZigString(env) else ZigString.Empty, + .message = msg.getZigString(env), + }; + result.* = system_error.toErrorInstance(env); + return .ok; +} +pub extern fn napi_create_type_error(env: napi_env, code: napi_value, msg: napi_value, result: *napi_value) napi_status; +pub extern fn napi_create_range_error(env: napi_env, code: napi_value, msg: napi_value, result: *napi_value) napi_status; +pub extern fn napi_typeof(env: napi_env, value: napi_value, result: *napi_valuetype) napi_status; +pub export fn napi_get_value_double(_: napi_env, value: napi_value, result: *f64) napi_status { + result.* = value.to(f64); + return .ok; +} +pub export fn napi_get_value_int32(_: napi_env, value: napi_value, result: *i32) napi_status { + result.* = value.to(i32); + return .ok; +} +pub export fn napi_get_value_uint32(_: napi_env, value: napi_value, result: *u32) napi_status { + result.* = value.to(u32); + return .ok; +} +pub export fn napi_get_value_int64(_: napi_env, value: napi_value, result: *i64) napi_status { + result.* = value.to(i64); + return .ok; +} +pub export fn napi_get_value_bool(_: napi_env, value: napi_value, result: *bool) napi_status { + result.* = value.to(bool); + return .ok; +} +pub export fn napi_get_value_string_latin1(env: napi_env, value: napi_value, buf: [*]u8, bufsize: usize, result: *usize) napi_status { + const zig_str = value.getZigString(env); + if (zig_str.is16Bit()) { + const utf16 = zig_str.utf16SliceAligned(); + const wrote = JSC.WebCore.Encoder.writeU16(utf16.ptr, utf16.len, buf, @minimum(utf16.len, bufsize), .latin1); + if (wrote < 0) { + return .generic_failure; + } + result.* = @intCast(usize, wrote); + return .ok; + } + + const to_copy = @minimum(zig_str.len, bufsize); + @memcpy(buf, zig_str.slice().ptr, to_copy); + result.* = to_copy; + return .ok; +} +pub export fn napi_get_value_string_utf8(env: napi_env, value: napi_value, buf: [*]u8, bufsize: usize, result: *usize) napi_status { + const zig_str = value.getZigString(env); + if (zig_str.is16Bit()) { + const utf16 = zig_str.utf16SliceAligned(); + const wrote = JSC.WebCore.Encoder.writeU16(utf16.ptr, utf16.len, buf, @minimum(utf16.len, bufsize), .utf8); + if (wrote < 0) { + return .generic_failure; + } + result.* = @intCast(usize, wrote); + return .ok; + } + + const to_copy = @minimum(zig_str.len, bufsize); + @memcpy(buf, zig_str.slice().ptr, to_copy); + result.* = to_copy; + return .ok; +} +pub export fn napi_get_value_string_utf16(env: napi_env, value: napi_value, buf: [*]char16_t, bufsize: usize, result: *usize) napi_status { + const zig_str = value.getZigString(env); + if (!zig_str.is16Bit()) { + const slice = zig_str.slice(); + const encode_into_result = strings.copyLatin1IntoUTF16([]char16_t, buf[0..bufsize], []const u8, slice); + result.* = encode_into_result.written; + return .ok; + } + + const to_copy = @minimum(zig_str.len, bufsize); + @memcpy(buf[0..], zig_str.utf16SliceAligned().ptr, to_copy); + result.* = to_copy; + return .ok; +} +pub export fn napi_coerce_to_bool(env: napi_env, value: napi_value, result: *napi_value) napi_status { + result.* = value.to(bool); + return .ok; +} +pub export fn napi_coerce_to_number(env: napi_env, value: napi_value, result: *napi_value) napi_status { + result.* = JSValue.from(JSC.C.JSValueToNumber(env.ref(), value.asObjectRef(), TODO_EXCEPTION)); + return .ok; +} +pub export fn napi_coerce_to_object(env: napi_env, value: napi_value, result: *napi_value) napi_status { + result.* = JSValue.from(JSC.C.JSValueToObject(env.ref(), value.asObjectRef(), TODO_EXCEPTION)); + return .ok; +} +pub export fn napi_coerce_to_string(env: napi_env, value: napi_value, result: *napi_value) napi_status { + result.* = value.to(bool) +} +pub extern fn napi_get_prototype(env: napi_env, object: napi_value, result: *napi_value) napi_status; +pub extern fn napi_get_property_names(env: napi_env, object: napi_value, result: *napi_value) napi_status; +pub extern fn napi_set_property(env: napi_env, object: napi_value, key: napi_value, value: napi_value) napi_status; +pub extern fn napi_has_property(env: napi_env, object: napi_value, key: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_get_property(env: napi_env, object: napi_value, key: napi_value, result: *napi_value) napi_status; +pub extern fn napi_delete_property(env: napi_env, object: napi_value, key: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_has_own_property(env: napi_env, object: napi_value, key: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_set_named_property(env: napi_env, object: napi_value, utf8name: [*c]const u8, value: napi_value) napi_status; +pub extern fn napi_has_named_property(env: napi_env, object: napi_value, utf8name: [*c]const u8, result: [*c]bool) napi_status; +pub extern fn napi_get_named_property(env: napi_env, object: napi_value, utf8name: [*c]const u8, result: *napi_value) napi_status; +pub extern fn napi_set_element(env: napi_env, object: napi_value, index: u32, value: napi_value) napi_status; +pub extern fn napi_has_element(env: napi_env, object: napi_value, index: u32, result: [*c]bool) napi_status; +pub extern fn napi_get_element(env: napi_env, object: napi_value, index: u32, result: *napi_value) napi_status; +pub extern fn napi_delete_element(env: napi_env, object: napi_value, index: u32, result: [*c]bool) napi_status; +pub extern fn napi_define_properties(env: napi_env, object: napi_value, property_count: usize, properties: [*c]const napi_property_descriptor) napi_status; +pub extern fn napi_is_array(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_get_array_length(env: napi_env, value: napi_value, result: [*c]u32) napi_status; +pub extern fn napi_strict_equals(env: napi_env, lhs: napi_value, rhs: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_call_function(env: napi_env, recv: napi_value, func: napi_value, argc: usize, argv: [*c]const napi_value, result: *napi_value) napi_status; +pub extern fn napi_new_instance(env: napi_env, constructor: napi_value, argc: usize, argv: [*c]const napi_value, result: *napi_value) napi_status; +pub extern fn napi_instanceof(env: napi_env, object: napi_value, constructor: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_get_cb_info(env: napi_env, cbinfo: napi_callback_info, argc: [*c]usize, argv: *napi_value, this_arg: *napi_value, data: [*]*anyopaque) napi_status; +pub extern fn napi_get_new_target(env: napi_env, cbinfo: napi_callback_info, result: *napi_value) napi_status; +pub extern fn napi_define_class(env: napi_env, utf8name: [*c]const u8, length: usize, constructor: napi_callback, data: ?*anyopaque, property_count: usize, properties: [*c]const napi_property_descriptor, result: *napi_value) napi_status; +pub extern fn napi_wrap(env: napi_env, js_object: napi_value, native_object: ?*anyopaque, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque, result: [*c]napi_ref) napi_status; +pub extern fn napi_unwrap(env: napi_env, js_object: napi_value, result: [*]*anyopaque) napi_status; +pub extern fn napi_remove_wrap(env: napi_env, js_object: napi_value, result: [*]*anyopaque) napi_status; +pub extern fn napi_create_external(env: napi_env, data: ?*anyopaque, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_get_value_external(env: napi_env, value: napi_value, result: [*]*anyopaque) napi_status; +pub extern fn napi_create_reference(env: napi_env, value: napi_value, initial_refcount: u32, result: [*c]napi_ref) napi_status; +pub extern fn napi_delete_reference(env: napi_env, ref: napi_ref) napi_status; +pub extern fn napi_reference_ref(env: napi_env, ref: napi_ref, result: [*c]u32) napi_status; +pub extern fn napi_reference_unref(env: napi_env, ref: napi_ref, result: [*c]u32) napi_status; +pub extern fn napi_get_reference_value(env: napi_env, ref: napi_ref, result: *napi_value) napi_status; +pub extern fn napi_open_handle_scope(env: napi_env, result: [*c]napi_handle_scope) napi_status; +pub extern fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope) napi_status; +pub extern fn napi_open_escapable_handle_scope(env: napi_env, result: [*c]napi_escapable_handle_scope) napi_status; +pub extern fn napi_close_escapable_handle_scope(env: napi_env, scope: napi_escapable_handle_scope) napi_status; +pub extern fn napi_escape_handle(env: napi_env, scope: napi_escapable_handle_scope, escapee: napi_value, result: *napi_value) napi_status; +pub extern fn napi_throw(env: napi_env, @"error": napi_value) napi_status; +pub extern fn napi_throw_error(env: napi_env, code: [*c]const u8, msg: [*c]const u8) napi_status; +pub extern fn napi_throw_type_error(env: napi_env, code: [*c]const u8, msg: [*c]const u8) napi_status; +pub extern fn napi_throw_range_error(env: napi_env, code: [*c]const u8, msg: [*c]const u8) napi_status; +pub extern fn napi_is_error(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_is_exception_pending(env: napi_env, result: [*c]bool) napi_status; +pub extern fn napi_get_and_clear_last_exception(env: napi_env, result: *napi_value) napi_status; +pub extern fn napi_is_arraybuffer(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_create_arraybuffer(env: napi_env, byte_length: usize, data: [*]*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_create_external_arraybuffer(env: napi_env, external_data: ?*anyopaque, byte_length: usize, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_get_arraybuffer_info(env: napi_env, arraybuffer: napi_value, data: [*]*anyopaque, byte_length: [*c]usize) napi_status; +pub extern fn napi_is_typedarray(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_create_typedarray(env: napi_env, @"type": napi_typedarray_type, length: usize, arraybuffer: napi_value, byte_offset: usize, result: *napi_value) napi_status; +pub extern fn napi_get_typedarray_info(env: napi_env, typedarray: napi_value, @"type": [*c]napi_typedarray_type, length: [*c]usize, data: [*]*anyopaque, arraybuffer: *napi_value, byte_offset: [*c]usize) napi_status; +pub extern fn napi_create_dataview(env: napi_env, length: usize, arraybuffer: napi_value, byte_offset: usize, result: *napi_value) napi_status; +pub extern fn napi_is_dataview(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_get_dataview_info(env: napi_env, dataview: napi_value, bytelength: [*c]usize, data: [*]*anyopaque, arraybuffer: *napi_value, byte_offset: [*c]usize) napi_status; +pub extern fn napi_get_version(env: napi_env, result: [*c]u32) napi_status; +pub extern fn napi_create_promise(env: napi_env, deferred: [*c]napi_deferred, promise: *napi_value) napi_status; +pub extern fn napi_resolve_deferred(env: napi_env, deferred: napi_deferred, resolution: napi_value) napi_status; +pub extern fn napi_reject_deferred(env: napi_env, deferred: napi_deferred, rejection: napi_value) napi_status; +pub extern fn napi_is_promise(env: napi_env, value: napi_value, is_promise: [*c]bool) napi_status; +pub extern fn napi_run_script(env: napi_env, script: napi_value, result: *napi_value) napi_status; +pub extern fn napi_adjust_external_memory(env: napi_env, change_in_bytes: i64, adjusted_value: [*c]i64) napi_status; +pub extern fn napi_create_date(env: napi_env, time: f64, result: *napi_value) napi_status; +pub extern fn napi_is_date(env: napi_env, value: napi_value, is_date: [*c]bool) napi_status; +pub extern fn napi_get_date_value(env: napi_env, value: napi_value, result: [*c]f64) napi_status; +pub extern fn napi_add_finalizer(env: napi_env, js_object: napi_value, native_object: ?*anyopaque, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque, result: [*c]napi_ref) napi_status; +pub extern fn napi_create_bigint_int64(env: napi_env, value: i64, result: *napi_value) napi_status; +pub extern fn napi_create_bigint_uint64(env: napi_env, value: u64, result: *napi_value) napi_status; +pub extern fn napi_create_bigint_words(env: napi_env, sign_bit: c_int, word_count: usize, words: [*c]const u64, result: *napi_value) napi_status; +pub extern fn napi_get_value_bigint_int64(env: napi_env, value: napi_value, result: [*c]i64, lossless: [*c]bool) napi_status; +pub extern fn napi_get_value_bigint_uint64(env: napi_env, value: napi_value, result: [*c]u64, lossless: [*c]bool) napi_status; +pub extern fn napi_get_value_bigint_words(env: napi_env, value: napi_value, sign_bit: [*c]c_int, word_count: [*c]usize, words: [*c]u64) napi_status; +pub extern fn napi_get_all_property_names(env: napi_env, object: napi_value, key_mode: napi_key_collection_mode, key_filter: napi_key_filter, key_conversion: napi_key_conversion, result: *napi_value) napi_status; +pub extern fn napi_set_instance_data(env: napi_env, data: ?*anyopaque, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque) napi_status; +pub extern fn napi_get_instance_data(env: napi_env, data: [*]*anyopaque) napi_status; +pub extern fn napi_detach_arraybuffer(env: napi_env, arraybuffer: napi_value) napi_status; +pub extern fn napi_is_detached_arraybuffer(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_type_tag_object(env: napi_env, value: napi_value, type_tag: [*c]const napi_type_tag) napi_status; +pub extern fn napi_check_object_type_tag(env: napi_env, value: napi_value, type_tag: [*c]const napi_type_tag, result: [*c]bool) napi_status; +pub extern fn napi_object_freeze(env: napi_env, object: napi_value) napi_status; +pub extern fn napi_object_seal(env: napi_env, object: napi_value) napi_status; +pub const struct_napi_callback_scope__ = opaque {}; +pub const napi_callback_scope = ?*struct_napi_callback_scope__; +pub const struct_napi_async_context__ = opaque {}; +pub const napi_async_context = ?*struct_napi_async_context__; +pub const struct_napi_async_work__ = opaque {}; +pub const napi_async_work = ?*struct_napi_async_work__; +pub const struct_napi_threadsafe_function__ = opaque {}; +pub const napi_threadsafe_function = ?*struct_napi_threadsafe_function__; +pub const napi_tsfn_release: c_int = 0; +pub const napi_tsfn_abort: c_int = 1; +pub const napi_threadsafe_function_release_mode = c_uint; +pub const napi_tsfn_nonblocking: c_int = 0; +pub const napi_tsfn_blocking: c_int = 1; +pub const napi_threadsafe_function_call_mode = c_uint; +pub const napi_async_execute_callback = ?fn (napi_env, ?*anyopaque) callconv(.C) void; +pub const napi_async_complete_callback = ?fn (napi_env, napi_status, ?*anyopaque) callconv(.C) void; +pub const napi_threadsafe_function_call_js = ?fn (napi_env, napi_value, ?*anyopaque, ?*anyopaque) callconv(.C) void; +pub const napi_node_version = extern struct { + major: u32, + minor: u32, + patch: u32, + release: [*c]const u8, +}; +pub const struct_napi_async_cleanup_hook_handle__ = opaque {}; +pub const napi_async_cleanup_hook_handle = ?*struct_napi_async_cleanup_hook_handle__; +pub const napi_async_cleanup_hook = ?fn (napi_async_cleanup_hook_handle, ?*anyopaque) callconv(.C) void; +pub const struct_uv_loop_s = opaque {}; +pub const napi_addon_register_func = ?fn (napi_env, napi_value) callconv(.C) napi_value; +pub const struct_napi_module = extern struct { + nm_version: c_int, + nm_flags: c_uint, + nm_filename: [*c]const u8, + nm_register_func: napi_addon_register_func, + nm_modname: [*c]const u8, + nm_priv: ?*anyopaque, + reserved: [4]?*anyopaque, +}; +pub const napi_module = struct_napi_module; +pub extern fn napi_module_register(mod: [*c]napi_module) void; +pub extern fn napi_fatal_error(location: [*c]const u8, location_len: usize, message: [*c]const u8, message_len: usize) noreturn; +pub extern fn napi_async_init(env: napi_env, async_resource: napi_value, async_resource_name: napi_value, result: [*c]napi_async_context) napi_status; +pub extern fn napi_async_destroy(env: napi_env, async_context: napi_async_context) napi_status; +pub extern fn napi_make_callback(env: napi_env, async_context: napi_async_context, recv: napi_value, func: napi_value, argc: usize, argv: [*c]const napi_value, result: *napi_value) napi_status; +pub extern fn napi_create_buffer(env: napi_env, length: usize, data: [*]*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_create_external_buffer(env: napi_env, length: usize, data: ?*anyopaque, finalize_cb: napi_finalize, finalize_hint: ?*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_create_buffer_copy(env: napi_env, length: usize, data: ?*const anyopaque, result_data: [*]*anyopaque, result: *napi_value) napi_status; +pub extern fn napi_is_buffer(env: napi_env, value: napi_value, result: [*c]bool) napi_status; +pub extern fn napi_get_buffer_info(env: napi_env, value: napi_value, data: [*]*anyopaque, length: [*c]usize) napi_status; +pub extern fn napi_create_async_work(env: napi_env, async_resource: napi_value, async_resource_name: napi_value, execute: napi_async_execute_callback, complete: napi_async_complete_callback, data: ?*anyopaque, result: [*c]napi_async_work) napi_status; +pub extern fn napi_delete_async_work(env: napi_env, work: napi_async_work) napi_status; +pub extern fn napi_queue_async_work(env: napi_env, work: napi_async_work) napi_status; +pub extern fn napi_cancel_async_work(env: napi_env, work: napi_async_work) napi_status; +pub extern fn napi_get_node_version(env: napi_env, version: [*c][*c]const napi_node_version) napi_status; +pub extern fn napi_get_uv_event_loop(env: napi_env, loop: [*]*struct_uv_loop_s) napi_status; +pub extern fn napi_fatal_exception(env: napi_env, err: napi_value) napi_status; +pub extern fn napi_add_env_cleanup_hook(env: napi_env, fun: ?fn (?*anyopaque) callconv(.C) void, arg: ?*anyopaque) napi_status; +pub extern fn napi_remove_env_cleanup_hook(env: napi_env, fun: ?fn (?*anyopaque) callconv(.C) void, arg: ?*anyopaque) napi_status; +pub extern fn napi_open_callback_scope(env: napi_env, resource_object: napi_value, context: napi_async_context, result: [*c]napi_callback_scope) napi_status; +pub extern fn napi_close_callback_scope(env: napi_env, scope: napi_callback_scope) napi_status; +pub extern fn napi_create_threadsafe_function(env: napi_env, func: napi_value, async_resource: napi_value, async_resource_name: napi_value, max_queue_size: usize, initial_thread_count: usize, thread_finalize_data: ?*anyopaque, thread_finalize_cb: napi_finalize, context: ?*anyopaque, call_js_cb: napi_threadsafe_function_call_js, result: [*c]napi_threadsafe_function) napi_status; +pub extern fn napi_get_threadsafe_function_context(func: napi_threadsafe_function, result: [*]*anyopaque) napi_status; +pub extern fn napi_call_threadsafe_function(func: napi_threadsafe_function, data: ?*anyopaque, is_blocking: napi_threadsafe_function_call_mode) napi_status; +pub extern fn napi_acquire_threadsafe_function(func: napi_threadsafe_function) napi_status; +pub extern fn napi_release_threadsafe_function(func: napi_threadsafe_function, mode: napi_threadsafe_function_release_mode) napi_status; +pub extern fn napi_unref_threadsafe_function(env: napi_env, func: napi_threadsafe_function) napi_status; +pub extern fn napi_ref_threadsafe_function(env: napi_env, func: napi_threadsafe_function) napi_status; +pub extern fn napi_add_async_cleanup_hook(env: napi_env, hook: napi_async_cleanup_hook, arg: ?*anyopaque, remove_handle: [*c]napi_async_cleanup_hook_handle) napi_status; +pub extern fn napi_remove_async_cleanup_hook(remove_handle: napi_async_cleanup_hook_handle) napi_status; + +pub const NAPI_VERSION_EXPERIMENTAL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const NAPI_VERSION = @as(c_int, 8); +pub const NAPI_AUTO_LENGTH = std.math.maxInt(usize); +pub const SRC_NODE_API_TYPES_H_ = ""; +pub const NAPI_MODULE_VERSION = @as(c_int, 1); diff --git a/src/napi/node_api.h b/src/napi/node_api.h new file mode 100644 index 000000000..0360ea329 --- /dev/null +++ b/src/napi/node_api.h @@ -0,0 +1,242 @@ +#ifndef SRC_NODE_API_H_ +#define SRC_NODE_API_H_ + +#ifdef BUILDING_NODE_EXTENSION +#ifdef _WIN32 +// Building native module against node +#define NAPI_EXTERN __declspec(dllimport) +#elif defined(__wasm32__) +#define NAPI_EXTERN __attribute__((__import_module__("napi"))) +#endif +#endif +#include "js_native_api.h" +#include "node_api_types.h" + +struct uv_loop_s; // Forward declaration. + +#ifdef _WIN32 +#define NAPI_MODULE_EXPORT __declspec(dllexport) +#else +#define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) +#endif + +#if defined(__GNUC__) +#define NAPI_NO_RETURN __attribute__((noreturn)) +#elif defined(_WIN32) +#define NAPI_NO_RETURN __declspec(noreturn) +#else +#define NAPI_NO_RETURN +#endif + +typedef napi_value (*napi_addon_register_func)(napi_env env, + napi_value exports); + +typedef struct napi_module { + int nm_version; + unsigned int nm_flags; + const char *nm_filename; + napi_addon_register_func nm_register_func; + const char *nm_modname; + void *nm_priv; + void *reserved[4]; +} napi_module; + +#define NAPI_MODULE_VERSION 1 + +#if defined(_MSC_VER) +#pragma section(".CRT$XCU", read) +#define NAPI_C_CTOR(fn) \ + static void __cdecl fn(void); \ + __declspec(dllexport, allocate(".CRT$XCU")) void(__cdecl * fn##_)(void) = \ + fn; \ + static void __cdecl fn(void) +#else +#define NAPI_C_CTOR(fn) \ + static void fn(void) __attribute__((constructor)); \ + static void fn(void) +#endif + +#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ + EXTERN_C_START \ + static napi_module _module = { \ + NAPI_MODULE_VERSION, flags, __FILE__, regfunc, #modname, priv, {0}, \ + }; \ + NAPI_C_CTOR(_register_##modname) { napi_module_register(&_module); } \ + EXTERN_C_END + +#define NAPI_MODULE_INITIALIZER_X(base, version) \ + NAPI_MODULE_INITIALIZER_X_HELPER(base, version) +#define NAPI_MODULE_INITIALIZER_X_HELPER(base, version) base##version + +#ifdef __wasm32__ +#define NAPI_WASM_INITIALIZER \ + NAPI_MODULE_INITIALIZER_X(napi_register_wasm_v, NAPI_MODULE_VERSION) +#define NAPI_MODULE(modname, regfunc) \ + EXTERN_C_START \ + NAPI_MODULE_EXPORT napi_value NAPI_WASM_INITIALIZER(napi_env env, \ + napi_value exports) { \ + return regfunc(env, exports); \ + } \ + EXTERN_C_END +#else +#define NAPI_MODULE(modname, regfunc) \ + NAPI_MODULE_X(modname, regfunc, NULL, 0) // NOLINT (readability/null_usage) +#endif + +#define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v + +#define NAPI_MODULE_INITIALIZER \ + NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION) + +#define NAPI_MODULE_INIT() \ + EXTERN_C_START \ + NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ + napi_value exports); \ + EXTERN_C_END \ + NAPI_MODULE(NODE_GYP_MODULE_NAME, NAPI_MODULE_INITIALIZER) \ + napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports) + +EXTERN_C_START + +NAPI_EXTERN void napi_module_register(napi_module *mod); + +NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char *location, + size_t location_len, + const char *message, + size_t message_len); + +// Methods for custom handling of async operations +NAPI_EXTERN napi_status napi_async_init(napi_env env, napi_value async_resource, + napi_value async_resource_name, + napi_async_context *result); + +NAPI_EXTERN napi_status napi_async_destroy(napi_env env, + napi_async_context async_context); + +NAPI_EXTERN napi_status napi_make_callback(napi_env env, + napi_async_context async_context, + napi_value recv, napi_value func, + size_t argc, const napi_value *argv, + napi_value *result); + +// Methods to provide node::Buffer functionality with napi types +NAPI_EXTERN napi_status napi_create_buffer(napi_env env, size_t length, + void **data, napi_value *result); +NAPI_EXTERN napi_status napi_create_external_buffer(napi_env env, size_t length, + void *data, + napi_finalize finalize_cb, + void *finalize_hint, + napi_value *result); +NAPI_EXTERN napi_status napi_create_buffer_copy(napi_env env, size_t length, + const void *data, + void **result_data, + napi_value *result); +NAPI_EXTERN napi_status napi_is_buffer(napi_env env, napi_value value, + bool *result); +NAPI_EXTERN napi_status napi_get_buffer_info(napi_env env, napi_value value, + void **data, size_t *length); + +// Methods to manage simple async operations +NAPI_EXTERN +napi_status napi_create_async_work(napi_env env, napi_value async_resource, + napi_value async_resource_name, + napi_async_execute_callback execute, + napi_async_complete_callback complete, + void *data, napi_async_work *result); +NAPI_EXTERN napi_status napi_delete_async_work(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status napi_queue_async_work(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env, + napi_async_work work); + +// version management +NAPI_EXTERN +napi_status napi_get_node_version(napi_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_get_uv_event_loop(napi_env env, + struct uv_loop_s **loop); + +#endif // NAPI_VERSION >= 2 + +#if NAPI_VERSION >= 3 + +NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err); + +NAPI_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env, + void (*fun)(void *arg), + void *arg); + +NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env, + void (*fun)(void *arg), + void *arg); + +NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env, + napi_value resource_object, + napi_async_context context, + napi_callback_scope *result); + +NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env, + napi_callback_scope scope); + +#endif // NAPI_VERSION >= 3 + +#if NAPI_VERSION >= 4 + +#ifndef __wasm32__ +// Calling into JS from other threads +NAPI_EXTERN napi_status napi_create_threadsafe_function( + napi_env env, napi_value func, napi_value async_resource, + napi_value async_resource_name, size_t max_queue_size, + size_t initial_thread_count, void *thread_finalize_data, + napi_finalize thread_finalize_cb, void *context, + napi_threadsafe_function_call_js call_js_cb, + napi_threadsafe_function *result); + +NAPI_EXTERN napi_status napi_get_threadsafe_function_context( + napi_threadsafe_function func, void **result); + +NAPI_EXTERN napi_status +napi_call_threadsafe_function(napi_threadsafe_function func, void *data, + napi_threadsafe_function_call_mode is_blocking); + +NAPI_EXTERN napi_status +napi_acquire_threadsafe_function(napi_threadsafe_function func); + +NAPI_EXTERN napi_status napi_release_threadsafe_function( + napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); + +NAPI_EXTERN napi_status +napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func); + +NAPI_EXTERN napi_status +napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func); +#endif // __wasm32__ + +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 8 + +NAPI_EXTERN napi_status napi_add_async_cleanup_hook( + napi_env env, napi_async_cleanup_hook hook, void *arg, + napi_async_cleanup_hook_handle *remove_handle); + +NAPI_EXTERN napi_status +napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle); + +#endif // NAPI_VERSION >= 8 + +#ifdef NAPI_EXPERIMENTAL + +NAPI_EXTERN napi_status node_api_get_module_file_name(napi_env env, + const char **result); + +#endif // NAPI_EXPERIMENTAL + +EXTERN_C_END + +#endif // SRC_NODE_API_H_ diff --git a/src/napi/node_api_types.h b/src/napi/node_api_types.h new file mode 100644 index 000000000..a5785a83a --- /dev/null +++ b/src/napi/node_api_types.h @@ -0,0 +1,47 @@ +#ifndef SRC_NODE_API_TYPES_H_ +#define SRC_NODE_API_TYPES_H_ + +#include "js_native_api_types.h" + +typedef struct napi_callback_scope__ *napi_callback_scope; +typedef struct napi_async_context__ *napi_async_context; +typedef struct napi_async_work__ *napi_async_work; +#if NAPI_VERSION >= 4 +typedef struct napi_threadsafe_function__ *napi_threadsafe_function; +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 4 +typedef enum { + napi_tsfn_release, + napi_tsfn_abort +} napi_threadsafe_function_release_mode; + +typedef enum { + napi_tsfn_nonblocking, + napi_tsfn_blocking +} napi_threadsafe_function_call_mode; +#endif // NAPI_VERSION >= 4 + +typedef void (*napi_async_execute_callback)(napi_env env, void *data); +typedef void (*napi_async_complete_callback)(napi_env env, napi_status status, + void *data); +#if NAPI_VERSION >= 4 +typedef void (*napi_threadsafe_function_call_js)(napi_env env, + napi_value js_callback, + void *context, void *data); +#endif // NAPI_VERSION >= 4 + +typedef struct { + uint32_t major; + uint32_t minor; + uint32_t patch; + const char *release; +} napi_node_version; + +#if NAPI_VERSION >= 8 +typedef struct napi_async_cleanup_hook_handle__ *napi_async_cleanup_hook_handle; +typedef void (*napi_async_cleanup_hook)(napi_async_cleanup_hook_handle handle, + void *data); +#endif // NAPI_VERSION >= 8 + +#endif // SRC_NODE_API_TYPES_H_ |