From 6d8a03e7074be631db845a02e192ef6f57f06272 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Tue, 28 Sep 2021 09:58:41 +0000
Subject: [PATCH] dawn_node: Add interop/Core.[h,cpp]

Core hand-written interop classes, which the template-generated code makes heavy use of.

There's currently no build rules for these files.
These will come in a followup change.

Bug: dawn:1123
Change-Id: Id56f96533070acc8ee581d6f44f83b5374662215
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/64901
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Austin Eng <enga@chromium.org>
---
 src/dawn_node/interop/Core.cpp | 154 +++++++++
 src/dawn_node/interop/Core.h   | 571 +++++++++++++++++++++++++++++++++
 2 files changed, 725 insertions(+)
 create mode 100644 src/dawn_node/interop/Core.cpp
 create mode 100644 src/dawn_node/interop/Core.h

diff --git a/src/dawn_node/interop/Core.cpp b/src/dawn_node/interop/Core.cpp
new file mode 100644
index 0000000000..7c505ca065
--- /dev/null
+++ b/src/dawn_node/interop/Core.cpp
@@ -0,0 +1,154 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/dawn_node/interop/Core.h"
+
+namespace wgpu { namespace interop {
+
+    bool Converter<bool>::FromJS(Napi::Env env, Napi::Value value, bool& out) {
+        if (value.IsBoolean()) {
+            out = value.ToBoolean();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<bool>::ToJS(Napi::Env env, bool value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<std::string>::FromJS(Napi::Env env, Napi::Value value, std::string& out) {
+        if (value.IsString()) {
+            out = value.ToString();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<std::string>::ToJS(Napi::Env env, std::string value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<int8_t>::FromJS(Napi::Env env, Napi::Value value, int8_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Int32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<int8_t>::ToJS(Napi::Env env, int8_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<uint8_t>::FromJS(Napi::Env env, Napi::Value value, uint8_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Uint32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<uint8_t>::ToJS(Napi::Env env, uint8_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<int16_t>::FromJS(Napi::Env env, Napi::Value value, int16_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Int32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<int16_t>::ToJS(Napi::Env env, int16_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<uint16_t>::FromJS(Napi::Env env, Napi::Value value, uint16_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Uint32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<uint16_t>::ToJS(Napi::Env env, uint16_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<int32_t>::FromJS(Napi::Env env, Napi::Value value, int32_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Int32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<int32_t>::ToJS(Napi::Env env, int32_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<uint32_t>::FromJS(Napi::Env env, Napi::Value value, uint32_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Uint32Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<uint32_t>::ToJS(Napi::Env env, uint32_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<int64_t>::FromJS(Napi::Env env, Napi::Value value, int64_t& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().Int64Value();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<int64_t>::ToJS(Napi::Env env, int64_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<uint64_t>::FromJS(Napi::Env env, Napi::Value value, uint64_t& out) {
+        if (value.IsNumber()) {
+            // Note that the JS Number type only stores doubles, so the max integer
+            // range of values without precision loss is -2^53 to 2^53 (52 bit mantissa
+            // with 1 implicit bit). This is why there's no UInt64Value() function.
+            out = static_cast<uint64_t>(value.ToNumber().Int64Value());
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<uint64_t>::ToJS(Napi::Env env, uint64_t value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<float>::FromJS(Napi::Env env, Napi::Value value, float& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().FloatValue();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<float>::ToJS(Napi::Env env, float value) {
+        return Napi::Value::From(env, value);
+    }
+
+    bool Converter<double>::FromJS(Napi::Env env, Napi::Value value, double& out) {
+        if (value.IsNumber()) {
+            out = value.ToNumber().DoubleValue();
+            return true;
+        }
+        return false;
+    }
+    Napi::Value Converter<double>::ToJS(Napi::Env env, double value) {
+        return Napi::Value::From(env, value);
+    }
+
+}}  // namespace wgpu::interop
diff --git a/src/dawn_node/interop/Core.h b/src/dawn_node/interop/Core.h
new file mode 100644
index 0000000000..1ad3bb9bee
--- /dev/null
+++ b/src/dawn_node/interop/Core.h
@@ -0,0 +1,571 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file provides core interop helpers used by the code generated by the
+// templates.
+
+#ifndef DAWN_NODE_INTEROP_CORE_WEBGPU_H_
+#define DAWN_NODE_INTEROP_CORE_WEBGPU_H_
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include "napi.h"
+
+#include "src/dawn_node/utils/Debug.h"
+
+#define ENABLE_INTEROP_LOGGING 0  // Enable for verbose interop logging
+
+#if ENABLE_INTEROP_LOGGING
+#    define INTEROP_LOG(...) LOG(__VA_ARGS__)
+#else
+#    define INTEROP_LOG(...)
+#endif
+
+namespace wgpu { namespace interop {
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Primitive JavaScript types
+    ////////////////////////////////////////////////////////////////////////////////
+    using Object = Napi::Object;
+    using ArrayBuffer = Napi::ArrayBuffer;
+    using Int8Array = Napi::TypedArrayOf<int8_t>;
+    using Int16Array = Napi::TypedArrayOf<int16_t>;
+    using Int32Array = Napi::TypedArrayOf<int32_t>;
+    using Uint8Array = Napi::TypedArrayOf<uint8_t>;
+    using Uint16Array = Napi::TypedArrayOf<uint16_t>;
+    using Uint32Array = Napi::TypedArrayOf<uint32_t>;
+    using Float32Array = Napi::TypedArrayOf<float>;
+    using Float64Array = Napi::TypedArrayOf<double>;
+    using DataView = Napi::TypedArray;
+
+    template <typename T>
+    using FrozenArray = std::vector<T>;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Interface<T>
+    ////////////////////////////////////////////////////////////////////////////////
+
+    // Interface<T> is a templated wrapper around a JavaScript object, which
+    // implements the template-generated interface type T. Interfaces are returned
+    // by either calling T::Bind() or T::Create().
+    template <typename T>
+    class Interface {
+      public:
+        // Constructs an Interface with no JS object.
+        inline Interface() {
+        }
+
+        // Constructs an Interface wrapping the given JS object.
+        // The JS object must have been created with a call to T::Bind().
+        explicit inline Interface(Napi::Object o) : object(o) {
+        }
+
+        // Implicit conversion operators to Napi objects.
+        inline operator napi_value() const {
+            return object;
+        }
+        inline operator const Napi::Value &() const {
+            return object;
+        }
+        inline operator const Napi::Object &() const {
+            return object;
+        }
+
+        // Member and dereference operators
+        inline T* operator->() const {
+            return T::Unwrap(object);
+        }
+        inline T* operator*() const {
+            return T::Unwrap(object);
+        }
+
+        // As<IMPL>() returns the unwrapped object cast to the implementation type.
+        // The interface implementation *must* be of the template type IMPL.
+        template <typename IMPL>
+        inline IMPL* As() const {
+            return static_cast<IMPL*>(T::Unwrap(object));
+        }
+
+      private:
+        Napi::Object object;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Promise<T>
+    ////////////////////////////////////////////////////////////////////////////////
+
+    // Promise<T> is a templated wrapper around a JavaScript promise, which can
+    // resolve to the template type T.
+    template <typename T>
+    class Promise {
+      public:
+        // Constructor
+        Promise(Napi::Env env) : deferred(Napi::Promise::Deferred::New(env)) {
+        }
+
+        // Implicit conversion operators to Napi promises.
+        inline operator napi_value() const {
+            return deferred.Promise();
+        }
+        inline operator Napi::Value() const {
+            return deferred.Promise();
+        }
+        inline operator Napi::Promise() const {
+            return deferred.Promise();
+        }
+
+        // Resolve() fulfills the promise with the given value.
+        void Resolve(T&& value) const {
+            deferred.Resolve(ToJS(deferred.Env(), std::forward<T>(value)));
+        }
+
+        // Reject() rejects the promise with the given failure value.
+        void Reject(Napi::Object obj) const {
+            deferred.Reject(obj);
+        }
+        void Reject(Napi::Error err) const {
+            deferred.Reject(err.Value());
+        }
+        void Reject(std::string err) const {
+            Reject(Napi::Error::New(deferred.Env(), err));
+        }
+
+      private:
+        Napi::Promise::Deferred deferred;
+    };
+
+    // Specialization for Promises that resolve with no value
+    template <>
+    class Promise<void> {
+      public:
+        // Constructor
+        Promise(Napi::Env env) : deferred(Napi::Promise::Deferred::New(env)) {
+        }
+
+        // Implicit conversion operators to Napi promises.
+        inline operator napi_value() const {
+            return deferred.Promise();
+        }
+        inline operator Napi::Value() const {
+            return deferred.Promise();
+        }
+        inline operator Napi::Promise() const {
+            return deferred.Promise();
+        }
+
+        // Resolve() fulfills the promise.
+        void Resolve() const {
+            deferred.Resolve(deferred.Env().Undefined());
+        }
+
+        // Reject() rejects the promise with the given failure value.
+        void Reject(Napi::Object obj) const {
+            deferred.Reject(obj);
+        }
+        void Reject(Napi::Error err) const {
+            deferred.Reject(err.Value());
+        }
+        void Reject(std::string err) const {
+            Reject(Napi::Error::New(deferred.Env(), err));
+        }
+
+      private:
+        Napi::Promise::Deferred deferred;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Converter<T>
+    ////////////////////////////////////////////////////////////////////////////////
+
+    // Converter<T> is specialized for each type T which can be converted from C++
+    // to JavaScript, or JavaScript to C++.
+    // Each specialization of Converter<T> is expected to have two static methods
+    // with the signatures:
+    //
+    //  // FromJS() converts the JavaScript value 'in' to the C++ value 'out'.
+    //  // Returns true on success, false on failure.
+    //  static bool FromJS(Napi::Env, Napi::Value in, T& out);
+    //
+    //  // ToJS() converts the C++ value 'in' to a JavaScript value, and returns
+    //  // this value.
+    //  static Napi::Value ToJS(Napi::Env, T in);
+    template <typename T>
+    class Converter {};
+
+    template <>
+    class Converter<Napi::Object> {
+      public:
+        static inline bool FromJS(Napi::Env, Napi::Value value, Napi::Object& out) {
+            if (value.IsObject()) {
+                out = value.ToObject();
+                return true;
+            }
+            return false;
+        }
+        static inline Napi::Value ToJS(Napi::Env, Napi::Object value) {
+            return value;
+        }
+    };
+
+    template <>
+    class Converter<ArrayBuffer> {
+      public:
+        static inline bool FromJS(Napi::Env, Napi::Value value, ArrayBuffer& out) {
+            if (value.IsArrayBuffer()) {
+                out = value.As<ArrayBuffer>();
+                return true;
+            }
+            return false;
+        };
+        static inline Napi::Value ToJS(Napi::Env, ArrayBuffer value) {
+            return value;
+        }
+    };
+
+    template <>
+    class Converter<Napi::TypedArray> {
+      public:
+        static inline bool FromJS(Napi::Env, Napi::Value value, Napi::TypedArray& out) {
+            if (value.IsTypedArray()) {
+                out = value.As<Napi::TypedArray>();
+                return true;
+            }
+            return false;
+        };
+        static inline Napi::Value ToJS(Napi::Env, ArrayBuffer value) {
+            return value;
+        }
+    };
+
+    template <typename T>
+    class Converter<Napi::TypedArrayOf<T>> {
+      public:
+        // clang-format off
+        // The Napi element type of T
+        static constexpr napi_typedarray_type element_type =
+              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
+            : std::is_same<T, int64_t>::value  ? napi_bigint64_array
+            : std::is_same<T, uint64_t>::value ? napi_biguint64_array
+            : static_cast<napi_typedarray_type>(-1);
+        // clang-format on
+        static_assert(static_cast<int>(element_type) >= 0,
+                      "unsupported T type for Napi::TypedArrayOf<T>");
+        static inline bool FromJS(Napi::Env, Napi::Value value, Napi::TypedArrayOf<T>& out) {
+            if (value.IsTypedArray()) {
+                auto arr = value.As<Napi::TypedArrayOf<T>>();
+                if (arr.TypedArrayType() == element_type) {
+                    out = arr;
+                }
+                return true;
+            }
+            return false;
+        };
+        static inline Napi::Value ToJS(Napi::Env, ArrayBuffer value) {
+            return value;
+        }
+    };
+
+    template <>
+    class Converter<std::string> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, std::string&);
+        static Napi::Value ToJS(Napi::Env, std::string);
+    };
+
+    template <>
+    class Converter<bool> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, bool&);
+        static Napi::Value ToJS(Napi::Env, bool);
+    };
+
+    template <>
+    class Converter<int8_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, int8_t&);
+        static Napi::Value ToJS(Napi::Env, int8_t);
+    };
+
+    template <>
+    class Converter<uint8_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, uint8_t&);
+        static Napi::Value ToJS(Napi::Env, uint8_t);
+    };
+
+    template <>
+    class Converter<int16_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, int16_t&);
+        static Napi::Value ToJS(Napi::Env, int16_t);
+    };
+
+    template <>
+    class Converter<uint16_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, uint16_t&);
+        static Napi::Value ToJS(Napi::Env, uint16_t);
+    };
+
+    template <>
+    class Converter<int32_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, int32_t&);
+        static Napi::Value ToJS(Napi::Env, int32_t);
+    };
+
+    template <>
+    class Converter<uint32_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, uint32_t&);
+        static Napi::Value ToJS(Napi::Env, uint32_t);
+    };
+
+    template <>
+    class Converter<int64_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, int64_t&);
+        static Napi::Value ToJS(Napi::Env, int64_t);
+    };
+
+    template <>
+    class Converter<uint64_t> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, uint64_t&);
+        static Napi::Value ToJS(Napi::Env, uint64_t);
+    };
+
+    template <>
+    class Converter<float> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, float&);
+        static Napi::Value ToJS(Napi::Env, float);
+    };
+
+    template <>
+    class Converter<double> {
+      public:
+        static bool FromJS(Napi::Env, Napi::Value, double&);
+        static Napi::Value ToJS(Napi::Env, double);
+    };
+
+    template <typename T>
+    class Converter<Interface<T>> {
+      public:
+        static bool FromJS(Napi::Env env, Napi::Value value, Interface<T>& out) {
+            if (value.IsObject()) {
+                auto obj = value.As<Napi::Object>();
+                if (T::Unwrap(obj)) {
+                    out = Interface<T>(obj);
+                    return true;
+                }
+            }
+            return false;
+        }
+        static Napi::Value ToJS(Napi::Env env, const Interface<T>& value) {
+            return {env, value};
+        }
+    };
+
+    template <typename T>
+    class Converter<std::optional<T>> {
+      public:
+        static bool FromJS(Napi::Env env, Napi::Value value, std::optional<T>& out) {
+            if (value.IsNull() || value.IsUndefined()) {
+                out.reset();
+                return true;
+            }
+            T v{};
+            if (!Converter<T>::FromJS(env, value, v)) {
+                return false;
+            }
+            out = std::move(v);
+            return true;
+        }
+        static Napi::Value ToJS(Napi::Env env, std::optional<T> value) {
+            if (value.has_value()) {
+                return Converter<T>::ToJS(env, value.value());
+            }
+            return env.Null();
+        }
+    };
+
+    template <typename T>
+    class Converter<std::vector<T>> {
+      public:
+        static inline bool FromJS(Napi::Env env, Napi::Value value, std::vector<T>& out) {
+            if (!value.IsArray()) {
+                return false;
+            }
+            auto arr = value.As<Napi::Array>();
+            std::vector<T> vec(arr.Length());
+            for (size_t i = 0; i < vec.size(); i++) {
+                if (!Converter<T>::FromJS(env, arr[static_cast<uint32_t>(i)], vec[i])) {
+                    return false;
+                }
+            }
+            out = std::move(vec);
+            return true;
+        }
+        static inline Napi::Value ToJS(Napi::Env env, const std::vector<T>& vec) {
+            auto arr = Napi::Array::New(env, vec.size());
+            for (size_t i = 0; i < vec.size(); i++) {
+                arr.Set(static_cast<uint32_t>(i), Converter<T>::ToJS(env, vec[i]));
+            }
+            return arr;
+        }
+    };
+
+    template <typename K, typename V>
+    class Converter<std::unordered_map<K, V>> {
+      public:
+        static inline bool FromJS(Napi::Env env, Napi::Value value, std::unordered_map<K, V>& out) {
+            if (!value.IsObject()) {
+                return false;
+            }
+            auto obj = value.ToObject();
+            auto keys = obj.GetPropertyNames();
+            std::unordered_map<K, V> map(keys.Length());
+            for (uint32_t i = 0; i < static_cast<uint32_t>(map.size()); i++) {
+                K key{};
+                V value{};
+                if (!Converter<K>::FromJS(env, keys[i], key) ||
+                    !Converter<V>::FromJS(env, obj.Get(keys[i]), value)) {
+                    return false;
+                }
+                map[key] = value;
+            }
+            out = std::move(map);
+            return true;
+        }
+        static inline Napi::Value ToJS(Napi::Env env, std::unordered_map<K, V> value) {
+            auto obj = Napi::Object::New(env);
+            for (auto it : value) {
+                obj.Set(Converter<K>::ToJS(env, it.first), Converter<V>::ToJS(env, it.second));
+            }
+            return obj;
+        }
+    };
+
+    template <typename... TYPES>
+    class Converter<std::variant<TYPES...>> {
+        template <typename TY>
+        static inline bool TryFromJS(Napi::Env env,
+                                     Napi::Value value,
+                                     std::variant<TYPES...>& out) {
+            TY v{};
+            if (Converter<TY>::FromJS(env, value, v)) {
+                out = std::move(v);
+                return true;
+            }
+            return false;
+        }
+
+        template <typename T0, typename T1, typename... TN>
+        static inline bool TryFromJS(Napi::Env env,
+                                     Napi::Value value,
+                                     std::variant<TYPES...>& out) {
+            if (TryFromJS<T0>(env, value, out)) {
+                return true;
+            }
+            return TryFromJS<T1, TN...>(env, value, out);
+        }
+
+      public:
+        static inline bool FromJS(Napi::Env env, Napi::Value value, std::variant<TYPES...>& out) {
+            return TryFromJS<TYPES...>(env, value, out);
+        }
+        static inline Napi::Value ToJS(Napi::Env env, std::variant<TYPES...> value) {
+            return std::visit(
+                [&](auto&& v) {
+                    using T = std::remove_cv_t<std::remove_reference_t<decltype(v)>>;
+                    return Converter<T>::ToJS(env, v);
+                },
+                value);
+        }
+    };
+
+    template <typename T>
+    class Converter<Promise<T>> {
+      public:
+        static inline bool FromJS(Napi::Env, Napi::Value, Promise<T>&) {
+            UNIMPLEMENTED();
+        }
+        static inline Napi::Value ToJS(Napi::Env, Promise<T> promise) {
+            return promise;
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Helpers
+    ////////////////////////////////////////////////////////////////////////////////
+
+    // FromJS() is a helper function which delegates to
+    // Converter<T>::FromJS()
+    template <typename T>
+    inline bool FromJS(Napi::Env env, Napi::Value value, T& out) {
+        return Converter<T>::FromJS(env, value, out);
+    }
+
+    // FromJSOptional() is similar to FromJS(), but if 'value' is either null
+    // or undefined then FromJSOptional() returns true and 'out' is left
+    // unassigned.
+    // Returns true on success, false on failure.
+    template <typename T>
+    inline bool FromJSOptional(Napi::Env env, Napi::Value value, T& out) {
+        if (value.IsNull() || value.IsUndefined()) {
+            return true;
+        }
+        return Converter<T>::FromJS(env, value, out);
+    }
+
+    // ToJS() is a helper function which delegates to Converter<T>::ToJS()
+    template <typename T>
+    inline Napi::Value ToJS(Napi::Env env, T&& value) {
+        return Converter<std::remove_cv_t<std::remove_reference_t<T>>>::ToJS(
+            env, std::forward<T>(value));
+    }
+
+    // FromJS() is a helper function for bulk converting the arguments of 'info'.
+    // PARAM_TYPES is a std::tuple<> describing the C++ function parameter types.
+    // Returns true on success, false on failure.
+    template <typename PARAM_TYPES, int BASE_INDEX = 0>
+    inline bool FromJS(const Napi::CallbackInfo& info, PARAM_TYPES& args) {
+        if constexpr (BASE_INDEX < std::tuple_size_v<PARAM_TYPES>) {
+            using T = std::tuple_element_t<BASE_INDEX, PARAM_TYPES>;
+            if (!FromJS<T>(info.Env(), info[BASE_INDEX], std::get<BASE_INDEX>(args))) {
+                return false;
+            }
+            return FromJS<PARAM_TYPES, BASE_INDEX + 1>(info, args);
+        } else {
+            return true;
+        }
+    }
+
+}}  // namespace wgpu::interop
+
+#endif  //  DAWN_NODE_INTEROP_CORE_WEBGPU_H_