How to implement js_traits<std::unique_ptr>? about quickjspp

[hc-tec]

With deeping into the source code these days, I know what js_traits do gradually.
js_traits::wrap is used to transform C++ object to JS object,js_traits::unwrap is used to transform JS object to C++ object.

The special of unique_ptr decides that there isn't a certain solution to solve this problem.
When we use unique_ptr to point our object, we own the ownership of this object.

My solution is to use a global map to manage the ownership of objects used in js_traits.

• When we use js_traits::wrap, we should transfer object ownership from unique_ptr to the global map, then use js_traits<T*>::wrap to transfrom raw ptr to JS object.
• When we use js_traits::unwrap, we should get object ownership back from the global map, return it to user.

template <class T>
struct js_traits<std::unique_ptr<T>> {

    static JSValue wrap(JSContext* ctx, std::unique_ptr<T> val) noexcept {
		T* raw_ptr = val.get();
                // transfer ownership to the global map which saves ownership temporately
		GetOwnershipMgr<T>()->ShiftOwner(std::move(val));
                // transform C++ object to JS object
		return js_traits<T*>::wrap(ctx, raw_ptr);
	}

    static std::unique_ptr<T> unwrap(JSContext* ctx, JSValueConst v)
    {
        std::unique_ptr<T> ptr = nullptr;
        if (JS_IsNull(v)) {
            return ptr;
        }
         // transform JS object to C++ object by js_traits<std::shared_ptr<T>>
        auto shared_ptr = js_traits<std::shared_ptr<T>>::unwrap(ctx, v);
        // get and return ownership to user from the global map
        return GetOwnershipMgr<T>()->GetOwner(shared_ptr.get());
    }
};

Above is just a simple thought to solve my problem, if you find some problems or better solutions, please feel free to comment.