#ifndef SRC_NAPI_H_

#define SRC_NAPI_H_

#include <node_api.h>

#include <functional>

#include <initializer_list>

#include <memory>

#include <mutex>

#include <string>

#include <vector>

// VS2015 RTM has bugs with constexpr, so require min of VS2015 Update 3 (known good version)

#if !defined(_MSC_VER) || _MSC_FULL_VER >= 190024210

#define NAPI_HAS_CONSTEXPR 1

#endif

// VS2013 does not support char16_t literal strings, so we'll work around it using wchar_t strings

// and casting them. This is safe as long as the character sizes are the same.

#if defined(_MSC_VER) && _MSC_VER <= 1800

static_assert(sizeof(char16_t) == sizeof(wchar_t), "Size mismatch between char16_t and wchar_t");

#define NAPI_WIDE_TEXT(x) reinterpret_cast<char16_t*>(L ## x)

#else

#define NAPI_WIDE_TEXT(x) u ## x

#endif

// If C++ exceptions are not explicitly enabled or disabled, enable them

// if exceptions were enabled in the compiler settings.

#if !defined(NAPI_CPP_EXCEPTIONS) && !defined(NAPI_DISABLE_CPP_EXCEPTIONS)

#if defined(_CPPUNWIND) || defined (__EXCEPTIONS)

#define NAPI_CPP_EXCEPTIONS

#else

#error Exception support not detected. \

Define either NAPI_CPP_EXCEPTIONS or NAPI_DISABLE_CPP_EXCEPTIONS.

#endif

#endif

#ifdef _NOEXCEPT

#define NAPI_NOEXCEPT _NOEXCEPT

#else

#define NAPI_NOEXCEPT noexcept

#endif

#ifdef NAPI_CPP_EXCEPTIONS

// When C++ exceptions are enabled, Errors are thrown directly. There is no need

// to return anything after the throw statements. The variadic parameter is an

// optional return value that is ignored.

// We need _VOID versions of the macros to avoid warnings resulting from

// leaving the NAPI_THROW_* `...` argument empty.

#define NAPI_THROW(e, ...) throw e

#define NAPI_THROW_VOID(e) throw e

#define NAPI_THROW_IF_FAILED(env, status, ...) \

if ((status) != napi_ok) throw Napi::Error::New(env);

#define NAPI_THROW_IF_FAILED_VOID(env, status) \

if ((status) != napi_ok) throw Napi::Error::New(env);

#else // NAPI_CPP_EXCEPTIONS

// When C++ exceptions are disabled, Errors are thrown as JavaScript exceptions,

// which are pending until the callback returns to JS. The variadic parameter

// is an optional return value; usually it is an empty result.

// We need _VOID versions of the macros to avoid warnings resulting from

// leaving the NAPI_THROW_* `...` argument empty.

#define NAPI_THROW(e, ...) \

do { \

(e).ThrowAsJavaScriptException(); \

return __VA_ARGS__; \

} while (0)

#define NAPI_THROW_VOID(e) \

do { \

(e).ThrowAsJavaScriptException(); \

return; \

} while (0)

#define NAPI_THROW_IF_FAILED(env, status, ...) \

if ((status) != napi_ok) { \

Napi::Error::New(env).ThrowAsJavaScriptException(); \

return __VA_ARGS__; \

}

#define NAPI_THROW_IF_FAILED_VOID(env, status) \

if ((status) != napi_ok) { \

Napi::Error::New(env).ThrowAsJavaScriptException(); \

return; \

}

#endif // NAPI_CPP_EXCEPTIONS

#define NAPI_FATAL_IF_FAILED(status, location, message) \

do { \

if ((status) != napi_ok) { \

Napi::Error::Fatal((location), (message)); \

} \

} while (0)

////////////////////////////////////////////////////////////////////////////////

/// N-API C++ Wrapper Classes

///

/// These classes wrap the "N-API" ABI-stable C APIs for Node.js, providing a

/// C++ object model and C++ exception-handling semantics with low overhead.

/// The wrappers are all header-only so that they do not affect the ABI.

////////////////////////////////////////////////////////////////////////////////

namespace Napi {

// Forward declarations

class Env;

class Value;

class Boolean;

class Number;

// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.

// Once it is no longer experimental guard with the NAPI_VERSION in which it is

// released instead.

#ifdef NAPI_EXPERIMENTAL

class BigInt;

#endif // NAPI_EXPERIMENTAL

#if (NAPI_VERSION > 4)

class Date;

#endif

class String;

class Object;

class Array;

class ArrayBuffer;

class Function;

template <typename T> class Buffer;

class Error;

class PropertyDescriptor;

class CallbackInfo;

template <typename T> class Reference;

class TypedArray;

template <typename T> class TypedArrayOf;

typedef TypedArrayOf<int8_t> Int8Array; ///< Typed-array of signed 8-bit integers

typedef TypedArrayOf<uint8_t> Uint8Array; ///< Typed-array of unsigned 8-bit integers

typedef TypedArrayOf<int16_t> Int16Array; ///< Typed-array of signed 16-bit integers

typedef TypedArrayOf<uint16_t> Uint16Array; ///< Typed-array of unsigned 16-bit integers

typedef TypedArrayOf<int32_t> Int32Array; ///< Typed-array of signed 32-bit integers

typedef TypedArrayOf<uint32_t> Uint32Array; ///< Typed-array of unsigned 32-bit integers

typedef TypedArrayOf<float> Float32Array; ///< Typed-array of 32-bit floating-point values

typedef TypedArrayOf<double> Float64Array; ///< Typed-array of 64-bit floating-point values

// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.

// Once it is no longer experimental guard with the NAPI_VERSION in which it is

// released instead.

#ifdef NAPI_EXPERIMENTAL

typedef TypedArrayOf<int64_t> BigInt64Array; ///< Typed array of signed 64-bit integers

typedef TypedArrayOf<uint64_t> BigUint64Array; ///< Typed array of unsigned 64-bit integers

#endif // NAPI_EXPERIMENTAL

/// Defines the signature of a N-API C++ module's registration callback (init) function.

typedef Object (*ModuleRegisterCallback)(Env env, Object exports);

class MemoryManagement;

/// Environment for N-API values and operations.

///

/// All N-API values and operations must be associated with an environment. An environment

/// instance is always provided to callback functions; that environment must then be used for any

/// creation of N-API values or other N-API operations within the callback. (Many methods infer

/// the environment from the `this` instance that the method is called on.)

///

/// In the future, multiple environments per process may be supported, although current

/// implementations only support one environment per process.

///

/// In the V8 JavaScript engine, a N-API environment approximately corresponds to an Isolate.

class Env {

public:

Env(napi_env env);

operator napi_env() const;

Object Global() const;

Value Undefined() const;

Value Null() const;

bool IsExceptionPending() const;

Error GetAndClearPendingException();

Value RunScript(const char* utf8script);

Value RunScript(const std::string& utf8script);

Value RunScript(String script);

private:

napi_env _env;

};

/// A JavaScript value of unknown type.

///

/// For type-specific operations, convert to one of the Value subclasses using a `To*` or `As()`

/// method. The `To*` methods do type coercion; the `As()` method does not.

///

/// Napi::Value value = ...

/// if (!value.IsString()) throw Napi::TypeError::New(env, "Invalid arg...");

/// Napi::String str = value.As<Napi::String>(); // Cast to a string value

///

/// Napi::Value anotherValue = ...

/// bool isTruthy = anotherValue.ToBoolean(); // Coerce to a boolean value

class Value {

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.

// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.

// Once it is no longer experimental guard with the NAPI_VERSION in which it is

// released instead.

#ifdef NAPI_EXPERIMENTAL

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

#endif // NAPI_EXPERIMENTAL

#if (NAPI_VERSION > 4)

bool IsDate() const; ///< Tests if a value is a JavaScript date.

#endif

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

};

/// A JavaScript boolean value.

class Boolean : public Value {

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.

};

/// A JavaScript number value.

class Number : public Value {

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.

};

// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.

// Once it is no longer experimental guard with the NAPI_VERSION in which it is

// released instead.

#ifdef NAPI_EXPERIMENTAL

/// A JavaScript bigint value.

class BigInt : public 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);

};

#endif // NAPI_EXPERIMENTAL

#if (NAPI_VERSION > 4)

/// A JavaScript date value.

class Date : public Value {

public:

/// Creates a new Date value from a double primitive.

static Date New(

napi_env env, ///< N-API environment

double value ///< Number value

);

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

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

operator double() const; ///< Converts a Date value to double primitive

double ValueOf() const; ///< Converts a Date value to a double primitive.

};

#endif

/// A JavaScript string or symbol value (that can be used as a property name).

class Name : public Value {

public:

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

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

};

/// A JavaScript string value.

class String : public Name {

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.

};

/// A JavaScript symbol value.

class Symbol : public Name {

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.

};

/// A JavaScript object value.

class Object : public Value {

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;

template <typename Finalizer, typename T>

inline void AddFinalizer(Finalizer finalizeCallback, T* data);

template <typename Finalizer, typename T, typename Hint>

inline void AddFinalizer(Finalizer finalizeCallback,

T* data,

Hint* finalizeHint);

};

template <typename T>

class External : public Value {

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;

};

class Array : public Object {

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;

};

/// A JavaScript array buffer value.

class ArrayBuffer : public Object {

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.

};

/// A JavaScript typed-array value with unknown array type.

///

/// For type-specific operations, cast to a `TypedArrayOf<T>` instance using the `As()`

/// method:

///

/// Napi::TypedArray array = ...

/// if (t.TypedArrayType() == napi_int32_array) {

/// Napi::Int32Array int32Array = t.As<Napi::Int32Array>();

/// }

class TypedArray : public Object {

public:

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

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

napi_typedarray_type TypedArrayType() const; ///< Gets the type of this typed-array.

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

uint8_t ElementSize() const; ///< Gets the size in bytes of one element in the array.

size_t ElementLength() const; ///< Gets the number of elements in the array.

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.

protected:

/// !cond INTERNAL

napi_typedarray_type _type;

size_t _length;

TypedArray(napi_env env, napi_value value, napi_typedarray_type type, size_t length);

static const napi_typedarray_type unknown_array_type = static_cast<napi_typedarray_type>(-1);

template <typename T>

static

#if defined(NAPI_HAS_CONSTEXPR)

constexpr

#endif

napi_typedarray_type TypedArrayTypeForPrimitiveType() {

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

// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.

// Once it is no longer experimental guard with the NAPI_VERSION in which it is

// released instead.

#ifdef NAPI_EXPERIMENTAL

: 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;

}

/// !endcond

};

/// A JavaScript typed-array value with known array type.

///

/// Note while it is possible to create and access Uint8 "clamped" arrays using this class,

/// the _clamping_ behavior is only applied in JavaScript.

template <typename T>

class TypedArrayOf : public TypedArray {

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);

};

/// The DataView provides a low-level interface for reading/writing multiple

/// number types in an ArrayBuffer irrespective of the platform's endianness.

class DataView : public Object {

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;

};

class Function : public Object {

public:

typedef void (*VoidCallback)(const CallbackInfo& info);

typedef Value (*Callback)(const CallbackInfo& info);

template <VoidCallback cb>

static Function New(napi_env env,

const char* utf8name = nullptr,

void* data = nullptr);