public:

Env(napi_env env);

operator napi_env() const;

Object Global() const;

Value Undefined() const;

Value Null() const;

bool IsExceptionPending() const;

Error GetAndClearPendingException();

private:

napi_env _env;

public:

Value(); ///< Creates a new _empty_ Value instance.

Value(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

/// Creates a JS value from a C++ primitive.

///

/// `value` may be any of:

/// - bool

/// - Any integer type

/// - Any floating point type

/// - const char* (encoded using UTF-8, null-terminated)

/// - const char16_t* (encoded using UTF-16-LE, null-terminated)

/// - std::string (encoded using UTF-8)

/// - std::u16string

/// - napi::Value

/// - napi_value

template <typename T>

static Value From(napi_env env, const T& value);

/// Converts to a N-API value primitive.

///

/// If the instance is _empty_, this returns `nullptr`.

operator napi_value() const;

/// Tests if this value strictly equals another value.

bool operator ==(const Value& other) const;

/// Tests if this value does not strictly equal another value.

bool operator !=(const Value& other) const;

/// Tests if this value strictly equals another value.

bool StrictEquals(const Value& other) const;

/// Gets the environment the value is associated with.

Napi::Env Env() const;

/// Checks if the value is empty (uninitialized).

///

/// An empty value is invalid, and most attempts to perform an operation on an empty value

/// will result in an exception. Note an empty value is distinct from JavaScript `null` or

/// `undefined`, which are valid values.

///

/// When C++ exceptions are disabled at compile time, a method with a `Value` return type may

/// return an empty value to indicate a pending exception. So when not using C++ exceptions,

/// callers should check whether the value is empty before attempting to use it.

bool IsEmpty() const;

napi_valuetype Type() const; ///< Gets the type of the value.

bool IsUndefined() const; ///< Tests if a value is an undefined JavaScript value.

bool IsNull() const; ///< Tests if a value is a null JavaScript value.

bool IsBoolean() const; ///< Tests if a value is a JavaScript boolean.

bool IsNumber() const; ///< Tests if a value is a JavaScript number.

#if (NAPI_VERSION > 2147483646)

bool IsBigInt() const; ///< Tests if a value is a JavaScript bigint.

#endif // NAPI_EXPERIMENTAL

bool IsString() const; ///< Tests if a value is a JavaScript string.

bool IsSymbol() const; ///< Tests if a value is a JavaScript symbol.

bool IsArray() const; ///< Tests if a value is a JavaScript array.

bool IsArrayBuffer() const; ///< Tests if a value is a JavaScript array buffer.

bool IsTypedArray() const; ///< Tests if a value is a JavaScript typed array.

bool IsObject() const; ///< Tests if a value is a JavaScript object.

bool IsFunction() const; ///< Tests if a value is a JavaScript function.

bool IsPromise() const; ///< Tests if a value is a JavaScript promise.

bool IsDataView() const; ///< Tests if a value is a JavaScript data view.

bool IsBuffer() const; ///< Tests if a value is a Node buffer.

bool IsExternal() const; ///< Tests if a value is a pointer to external data.

/// Casts to another type of `Napi::Value`, when the actual type is known or assumed.

///

/// This conversion does NOT coerce the type. Calling any methods inappropriate for the actual

/// value type will throw `Napi::Error`.

template <typename T> T As() const;

Boolean ToBoolean() const; ///< Coerces a value to a JavaScript boolean.

Number ToNumber() const; ///< Coerces a value to a JavaScript number.

String ToString() const; ///< Coerces a value to a JavaScript string.

Object ToObject() const; ///< Coerces a value to a JavaScript object.

protected:

/// !cond INTERNAL

napi_env _env;

napi_value _value;

/// !endcond

public:

static Boolean New(

napi_env env, ///< N-API environment

bool value ///< Boolean value

);

Boolean(); ///< Creates a new _empty_ Boolean instance.

Boolean(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

operator bool() const; ///< Converts a Boolean value to a boolean primitive.

bool Value() const; ///< Converts a Boolean value to a boolean primitive.

public:

static Number New(

napi_env env, ///< N-API environment

double value ///< Number value

);

Number(); ///< Creates a new _empty_ Number instance.

Number(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

operator int32_t() const; ///< Converts a Number value to a 32-bit signed integer value.

operator uint32_t() const; ///< Converts a Number value to a 32-bit unsigned integer value.

operator int64_t() const; ///< Converts a Number value to a 64-bit signed integer value.

operator float() const; ///< Converts a Number value to a 32-bit floating-point value.

operator double() const; ///< Converts a Number value to a 64-bit floating-point value.

int32_t Int32Value() const; ///< Converts a Number value to a 32-bit signed integer value.

uint32_t Uint32Value() const; ///< Converts a Number value to a 32-bit unsigned integer value.

int64_t Int64Value() const; ///< Converts a Number value to a 64-bit signed integer value.

float FloatValue() const; ///< Converts a Number value to a 32-bit floating-point value.

double DoubleValue() const; ///< Converts a Number value to a 64-bit floating-point value.

public:

static BigInt New(

napi_env env, ///< N-API environment

int64_t value ///< Number value

);

static BigInt New(

napi_env env, ///< N-API environment

uint64_t value ///< Number value

);

/// Creates a new BigInt object using a specified sign bit and a

/// specified list of digits/words.

/// The resulting number is calculated as:

/// (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...)

static BigInt New(

napi_env env, ///< N-API environment

int sign_bit, ///< Sign bit. 1 if negative.

size_t word_count, ///< Number of words in array

const uint64_t* words ///< Array of words

);

BigInt(); ///< Creates a new _empty_ BigInt instance.

BigInt(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

int64_t Int64Value(bool* lossless) const; ///< Converts a BigInt value to a 64-bit signed integer value.

uint64_t Uint64Value(bool* lossless) const; ///< Converts a BigInt value to a 64-bit unsigned integer value.

size_t WordCount() const; ///< The number of 64-bit words needed to store the result of ToWords().

/// Writes the contents of this BigInt to a specified memory location.

/// `sign_bit` must be provided and will be set to 1 if this BigInt is negative.

/// `*word_count` has to be initialized to the length of the `words` array.

/// Upon return, it will be set to the actual number of words that would

/// be needed to store this BigInt (i.e. the return value of `WordCount()`).

void ToWords(int* sign_bit, size_t* word_count, uint64_t* words);

public:

Name(); ///< Creates a new _empty_ Name instance.

Name(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

public:

/// Creates a new String value from a UTF-8 encoded C++ string.

static String New(

napi_env env, ///< N-API environment

const std::string& value ///< UTF-8 encoded C++ string

);

/// Creates a new String value from a UTF-16 encoded C++ string.

static String New(

napi_env env, ///< N-API environment

const std::u16string& value ///< UTF-16 encoded C++ string

);

/// Creates a new String value from a UTF-8 encoded C string.

static String New(

napi_env env, ///< N-API environment

const char* value ///< UTF-8 encoded null-terminated C string

);

/// Creates a new String value from a UTF-16 encoded C string.

static String New(

napi_env env, ///< N-API environment

const char16_t* value ///< UTF-16 encoded null-terminated C string

);

/// Creates a new String value from a UTF-8 encoded C string with specified length.

static String New(

napi_env env, ///< N-API environment

const char* value, ///< UTF-8 encoded C string (not necessarily null-terminated)

size_t length ///< length of the string in bytes

);

/// Creates a new String value from a UTF-16 encoded C string with specified length.

static String New(

napi_env env, ///< N-API environment

const char16_t* value, ///< UTF-16 encoded C string (not necessarily null-terminated)

size_t length ///< Length of the string in 2-byte code units

);

/// Creates a new String based on the original object's type.

///

/// `value` may be any of:

/// - const char* (encoded using UTF-8, null-terminated)

/// - const char16_t* (encoded using UTF-16-LE, null-terminated)

/// - std::string (encoded using UTF-8)

/// - std::u16string

template <typename T>

static String From(napi_env env, const T& value);

String(); ///< Creates a new _empty_ String instance.

String(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

operator std::string() const; ///< Converts a String value to a UTF-8 encoded C++ string.

operator std::u16string() const; ///< Converts a String value to a UTF-16 encoded C++ string.

std::string Utf8Value() const; ///< Converts a String value to a UTF-8 encoded C++ string.

std::u16string Utf16Value() const; ///< Converts a String value to a UTF-16 encoded C++ string.

public:

/// Creates a new Symbol value with an optional description.

static Symbol New(

napi_env env, ///< N-API environment

const char* description = nullptr ///< Optional UTF-8 encoded null-terminated C string

/// describing the symbol

);

/// Creates a new Symbol value with a description.

static Symbol New(

napi_env env, ///< N-API environment

const std::string& description ///< UTF-8 encoded C++ string describing the symbol

);

/// Creates a new Symbol value with a description.

static Symbol New(

napi_env env, ///< N-API environment

String description ///< String value describing the symbol

);

/// Creates a new Symbol value with a description.

static Symbol New(

napi_env env, ///< N-API environment

napi_value description ///< String value describing the symbol

);

/// Get a public Symbol (e.g. Symbol.iterator).

static Symbol WellKnown(napi_env, const std::string& name);

Symbol(); ///< Creates a new _empty_ Symbol instance.

Symbol(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

public:

/// Enables property and element assignments using indexing syntax.

///

/// Example:

///

/// Napi::Value propertyValue = object1['A'];

/// object2['A'] = propertyValue;

/// Napi::Value elementValue = array[0];

/// array[1] = elementValue;

template <typename Key>

class PropertyLValue {

public:

/// Converts an L-value to a value.

operator Value() const;

/// Assigns a value to the property. The type of value can be

/// anything supported by `Object::Set`.

template <typename ValueType>

PropertyLValue& operator =(ValueType value);

private:

PropertyLValue() = delete;

PropertyLValue(Object object, Key key);

napi_env _env;

napi_value _object;

Key _key;

friend class Napi::Object;

};

/// Creates a new Object value.

static Object New(

napi_env env ///< N-API environment

);

Object(); ///< Creates a new _empty_ Object instance.

Object(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

/// Gets or sets a named property.

PropertyLValue<std::string> operator [](

const char* utf8name ///< UTF-8 encoded null-terminated property name

);

/// Gets or sets a named property.

PropertyLValue<std::string> operator [](

const std::string& utf8name ///< UTF-8 encoded property name

);

/// Gets or sets an indexed property or array element.

PropertyLValue<uint32_t> operator [](

uint32_t index /// Property / element index

);

/// Gets a named property.

Value operator [](

const char* utf8name ///< UTF-8 encoded null-terminated property name

) const;

/// Gets a named property.

Value operator [](

const std::string& utf8name ///< UTF-8 encoded property name

) const;

/// Gets an indexed property or array element.

Value operator [](

uint32_t index ///< Property / element index

) const;

/// Checks whether a property is present.

bool Has(

napi_value key ///< Property key primitive

) const;

/// Checks whether a property is present.

bool Has(

Value key ///< Property key

) const;

/// Checks whether a named property is present.

bool Has(

const char* utf8name ///< UTF-8 encoded null-terminated property name

) const;

/// Checks whether a named property is present.

bool Has(

const std::string& utf8name ///< UTF-8 encoded property name

) const;

/// Checks whether a own property is present.

bool HasOwnProperty(

napi_value key ///< Property key primitive

) const;

/// Checks whether a own property is present.

bool HasOwnProperty(

Value key ///< Property key

) const;

/// Checks whether a own property is present.

bool HasOwnProperty(

const char* utf8name ///< UTF-8 encoded null-terminated property name

) const;

/// Checks whether a own property is present.

bool HasOwnProperty(

const std::string& utf8name ///< UTF-8 encoded property name

) const;

/// Gets a property.

Value Get(

napi_value key ///< Property key primitive

) const;

/// Gets a property.

Value Get(

Value key ///< Property key

) const;

/// Gets a named property.

Value Get(

const char* utf8name ///< UTF-8 encoded null-terminated property name

) const;

/// Gets a named property.

Value Get(

const std::string& utf8name ///< UTF-8 encoded property name

) const;

/// Sets a property.

template <typename ValueType>

void Set(

napi_value key, ///< Property key primitive

const ValueType& value ///< Property value primitive

);

/// Sets a property.

template <typename ValueType>

void Set(

Value key, ///< Property key

const ValueType& value ///< Property value

);

/// Sets a named property.

template <typename ValueType>

void Set(

const char* utf8name, ///< UTF-8 encoded null-terminated property name

const ValueType& value

);

/// Sets a named property.

template <typename ValueType>

void Set(

const std::string& utf8name, ///< UTF-8 encoded property name

const ValueType& value ///< Property value primitive

);

/// Delete property.

bool Delete(

napi_value key ///< Property key primitive

);

/// Delete property.

bool Delete(

Value key ///< Property key

);

/// Delete property.

bool Delete(

const char* utf8name ///< UTF-8 encoded null-terminated property name

);

/// Delete property.

bool Delete(

const std::string& utf8name ///< UTF-8 encoded property name

);

/// Checks whether an indexed property is present.

bool Has(

uint32_t index ///< Property / element index

) const;

/// Gets an indexed property or array element.

Value Get(

uint32_t index ///< Property / element index

) const;

/// Sets an indexed property or array element.

template <typename ValueType>

void Set(

uint32_t index, ///< Property / element index

const ValueType& value ///< Property value primitive

);

/// Deletes an indexed property or array element.

bool Delete(

uint32_t index ///< Property / element index

);

Array GetPropertyNames() const; ///< Get all property names

/// Defines a property on the object.

void DefineProperty(

const PropertyDescriptor& property ///< Descriptor for the property to be defined

);

/// Defines properties on the object.

void DefineProperties(

const std::initializer_list<PropertyDescriptor>& properties

///< List of descriptors for the properties to be defined

);

/// Defines properties on the object.

void DefineProperties(

const std::vector<PropertyDescriptor>& properties

///< Vector of descriptors for the properties to be defined

);

/// Checks if an object is an instance created by a constructor function.

///

/// This is equivalent to the JavaScript `instanceof` operator.

bool InstanceOf(

const Function& constructor ///< Constructor function

) const;

public:

static External New(napi_env env, T* data);

// Finalizer must implement `void operator()(Env env, T* data)`.

template <typename Finalizer>

static External New(napi_env env,

T* data,

Finalizer finalizeCallback);

// Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`.

template <typename Finalizer, typename Hint>

static External New(napi_env env,

T* data,

Finalizer finalizeCallback,

Hint* finalizeHint);

External();

External(napi_env env, napi_value value);

T* Data() const;

public:

static Array New(napi_env env);

static Array New(napi_env env, size_t length);

Array();

Array(napi_env env, napi_value value);

uint32_t Length() const;

public:

/// Creates a new ArrayBuffer instance over a new automatically-allocated buffer.

static ArrayBuffer New(

napi_env env, ///< N-API environment

size_t byteLength ///< Length of the buffer to be allocated, in bytes

);

/// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.

static ArrayBuffer New(

napi_env env, ///< N-API environment

void* externalData, ///< Pointer to the external buffer to be used by the array

size_t byteLength ///< Length of the external buffer to be used by the array, in bytes

);

/// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.

template <typename Finalizer>

static ArrayBuffer New(

napi_env env, ///< N-API environment

void* externalData, ///< Pointer to the external buffer to be used by the array

size_t byteLength, ///< Length of the external buffer to be used by the array,

/// in bytes

Finalizer finalizeCallback ///< Function to be called when the array buffer is destroyed;

/// must implement `void operator()(Env env, void* externalData)`

);

/// Creates a new ArrayBuffer instance, using an external buffer with specified byte length.

template <typename Finalizer, typename Hint>

static ArrayBuffer New(

napi_env env, ///< N-API environment

void* externalData, ///< Pointer to the external buffer to be used by the array

size_t byteLength, ///< Length of the external buffer to be used by the array,

/// in bytes

Finalizer finalizeCallback, ///< Function to be called when the array buffer is destroyed;

/// must implement `void operator()(Env env, void* externalData, Hint* hint)`

Hint* finalizeHint ///< Hint (second parameter) to be passed to the finalize callback

);

ArrayBuffer(); ///< Creates a new _empty_ ArrayBuffer instance.

ArrayBuffer(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

void* Data(); ///< Gets a pointer to the data buffer.

size_t ByteLength(); ///< Gets the length of the array buffer in bytes.

private:

mutable void* _data;

mutable size_t _length;

ArrayBuffer(napi_env env, napi_value value, void* data, size_t length);

void EnsureInfo() const;

return std::is_same<T, int8_t>::value ? napi_int8_array

: std::is_same<T, uint8_t>::value ? napi_uint8_array

: std::is_same<T, int16_t>::value ? napi_int16_array

: std::is_same<T, uint16_t>::value ? napi_uint16_array

: std::is_same<T, int32_t>::value ? napi_int32_array

: std::is_same<T, uint32_t>::value ? napi_uint32_array

: std::is_same<T, float>::value ? napi_float32_array

: std::is_same<T, double>::value ? napi_float64_array

#if (NAPI_VERSION > 2147483646)

: std::is_same<T, int64_t>::value ? napi_bigint64_array

: std::is_same<T, uint64_t>::value ? napi_biguint64_array

#endif // NAPI_EXPERIMENTAL

: unknown_array_type;

public:

/// Creates a new TypedArray instance over a new automatically-allocated array buffer.

///

/// The array type parameter can normally be omitted (because it is inferred from the template

/// parameter T), except when creating a "clamped" array:

///

/// Uint8Array::New(env, length, napi_uint8_clamped_array)

static TypedArrayOf New(

napi_env env, ///< N-API environment

size_t elementLength, ///< Length of the created array, as a number of elements

#if defined(NAPI_HAS_CONSTEXPR)

napi_typedarray_type type = TypedArray::TypedArrayTypeForPrimitiveType<T>()

#else

napi_typedarray_type type

#endif

///< Type of array, if different from the default array type for the template parameter T.

);

/// Creates a new TypedArray instance over a provided array buffer.

///

/// The array type parameter can normally be omitted (because it is inferred from the template

/// parameter T), except when creating a "clamped" array:

///

/// Uint8Array::New(env, length, buffer, 0, napi_uint8_clamped_array)

static TypedArrayOf New(

napi_env env, ///< N-API environment

size_t elementLength, ///< Length of the created array, as a number of elements

Napi::ArrayBuffer arrayBuffer, ///< Backing array buffer instance to use

size_t bufferOffset, ///< Offset into the array buffer where the typed-array starts

#if defined(NAPI_HAS_CONSTEXPR)

napi_typedarray_type type = TypedArray::TypedArrayTypeForPrimitiveType<T>()

#else

napi_typedarray_type type

#endif

///< Type of array, if different from the default array type for the template parameter T.

);

TypedArrayOf(); ///< Creates a new _empty_ TypedArrayOf instance.

TypedArrayOf(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

T& operator [](size_t index); ///< Gets or sets an element in the array.

const T& operator [](size_t index) const; ///< Gets an element in the array.

/// Gets a pointer to the array's backing buffer.

///

/// This is not necessarily the same as the `ArrayBuffer::Data()` pointer, because the

/// typed-array may have a non-zero `ByteOffset()` into the `ArrayBuffer`.

T* Data();

/// Gets a pointer to the array's backing buffer.

///

/// This is not necessarily the same as the `ArrayBuffer::Data()` pointer, because the

/// typed-array may have a non-zero `ByteOffset()` into the `ArrayBuffer`.

const T* Data() const;

private:

T* _data;

TypedArrayOf(napi_env env,

napi_value value,

napi_typedarray_type type,

size_t length,

T* data);

public:

static DataView New(napi_env env,

Napi::ArrayBuffer arrayBuffer);

static DataView New(napi_env env,

Napi::ArrayBuffer arrayBuffer,

size_t byteOffset);

static DataView New(napi_env env,

Napi::ArrayBuffer arrayBuffer,

size_t byteOffset,

size_t byteLength);

DataView(); ///< Creates a new _empty_ DataView instance.

DataView(napi_env env, napi_value value); ///< Wraps a N-API value primitive.

Napi::ArrayBuffer ArrayBuffer() const; ///< Gets the backing array buffer.

size_t ByteOffset() const; ///< Gets the offset into the buffer where the array starts.

size_t ByteLength() const; ///< Gets the length of the array in bytes.

void* Data() const;

float GetFloat32(size_t byteOffset) const;

double GetFloat64(size_t byteOffset) const;

int8_t GetInt8(size_t byteOffset) const;

int16_t GetInt16(size_t byteOffset) const;

int32_t GetInt32(size_t byteOffset) const;

uint8_t GetUint8(size_t byteOffset) const;

uint16_t GetUint16(size_t byteOffset) const;

uint32_t GetUint32(size_t byteOffset) const;

void SetFloat32(size_t byteOffset, float value) const;

void SetFloat64(size_t byteOffset, double value) const;

void SetInt8(size_t byteOffset, int8_t value) const;

void SetInt16(size_t byteOffset, int16_t value) const;

void SetInt32(size_t byteOffset, int32_t value) const;

void SetUint8(size_t byteOffset, uint8_t value) const;

void SetUint16(size_t byteOffset, uint16_t value) const;

void SetUint32(size_t byteOffset, uint32_t value) const;

private:

template <typename T>

T ReadData(size_t byteOffset) const;

template <typename T>

void WriteData(size_t byteOffset, T value) const;

void* _data;

size_t _length;

public:

/// Callable must implement operator() accepting a const CallbackInfo&

/// and return either void or Value.

template <typename Callable>

static Function New(napi_env env,

Callable cb,

const char* utf8name = nullptr,

void* data = nullptr);

/// Callable must implement operator() accepting a const CallbackInfo&

/// and return either void or Value.

template <typename Callable>

static Function New(napi_env env,

Callable cb,

const std::string& utf8name,

void* data = nullptr);

Function();

Function(napi_env env, napi_value value);

Value operator ()(const std::initializer_list<napi_value>& args) const;

Value Call(const std::initializer_list<napi_value>& args) const;

Value Call(const std::vector<napi_value>& args) const;

Value Call(size_t argc, const napi_value* args) const;

Value Call(napi_value recv, const std::initializer_list<napi_value>& args) const;

Value Call(napi_value recv, const std::vector<napi_value>& args) const;

Value Call(napi_value recv, size_t argc, const napi_value* args) const;

Value MakeCallback(napi_value recv,

const std::initializer_list<napi_value>& args,

napi_async_context context = nullptr) const;

Value MakeCallback(napi_value recv,

const std::vector<napi_value>& args,

napi_async_context context = nullptr) const;

Value MakeCallback(napi_value recv,

size_t argc,

const napi_value* args,

napi_async_context context = nullptr) const;

Object New(const std::initializer_list<napi_value>& args) const;

Object New(const std::vector<napi_value>& args) const;

Object New(size_t argc, const napi_value* args) const;