@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.21

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -11,7 +11,7 @@
 #include "Helpers.h"
 #include "Common.h"
 
-ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
+ImageAssetImpl::ImageAssetImpl(const ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
@@ -122,12 +122,12 @@ void ImageAssetImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType(ret, NativeType::ImageAsset);
-
     auto image_asset = canvas_native_image_asset_create();
 
     auto object = new ImageAssetImpl(image_asset);
 
+    SetNativeType(object, NativeType::ImageAsset);
+
     ret->SetAlignedPointerInInternalField(0, object);
 
     object->BindFinalizer(isolate, ret);
@@ -240,7 +240,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -269,8 +269,6 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
@@ -412,19 +410,17 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     auto path = ConvertFromV8String(isolate, args[0]);
 
-    auto asset = canvas_native_image_asset_reference(
-            ptr->GetImageAsset());
+    auto asset = canvas_native_image_asset_reference(ptr->GetImageAsset());
 
     auto callback = args[1].As<v8::Function>();
 
-
     auto jsi_callback = new JSICallback(isolate, callback);
 
 #ifdef __ANDROID__
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -443,7 +439,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                       v8::Local<v8::Value> args[1] = {v8::Boolean::New(isolate, done)};
 
-                      // v8::TryCatch tc(isolate);
+                       v8::TryCatch tc(isolate);
 
                       callback->Call(context, context->Global(), 1,
                                      args);  // ignore JS return value
@@ -452,23 +448,23 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
-                    const std::string &path) {
+                    const std::string path) {
 
                 auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
 
-                canvas_native_image_asset_release(asset);
-
                 write(jsi_callback->fd_[1],
                       &done,
                       sizeof(bool));
 
+                canvas_native_image_asset_release(asset);
+
             }, std::move(path));
 
+    thread.detach();
+
 #endif
 
 
@@ -481,7 +477,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto task = [jsi_callback, current_queue, queue, asset, path]() {
 
         auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
-
+        
         canvas_native_image_asset_release(asset);
 
         auto main_task = [jsi_callback, current_queue, queue, done]() {
@@ -514,6 +510,8 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     };
 
     queue->addOperation(task);
+    
+
 #endif
 }
 
@@ -572,7 +570,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -600,9 +598,6 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, data, size]() {
 
@@ -713,7 +708,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -741,9 +736,6 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, format](
                     const std::string &path) {
@@ -813,7 +805,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 }
 */
 
-ImageAsset *ImageAssetImpl::GetImageAsset() {
+const ImageAsset *ImageAssetImpl::GetImageAsset() {
     return this->asset_;
 }
 

package/platforms/ios/src/cpp/ImageAssetImpl.h

@@ -19,11 +19,11 @@
 class ImageAssetImpl : ObjectWrapperImpl {
 public:
 
-    explicit ImageAssetImpl(ImageAsset *asset);
+    explicit ImageAssetImpl(const ImageAsset *asset);
 
     ~ImageAssetImpl();
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -67,5 +67,5 @@ public:
 
 
 private:
-    ImageAsset *asset_;
+    const ImageAsset *asset_;
 };

package/platforms/ios/src/cpp/ImageBitmapImpl.cpp

@@ -5,10 +5,10 @@
 #include "ImageBitmapImpl.h"
 #include "Caches.h"
 
-ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+ImageBitmapImpl::ImageBitmapImpl(const ImageAsset *asset)
         : bitmap_(asset) {}
 
-ImageBitmapImpl::~ImageBitmapImpl(){
+ImageBitmapImpl::~ImageBitmapImpl() {
     canvas_native_image_asset_release(bitmap_);
     this->bitmap_ = nullptr;
 }
@@ -26,6 +26,23 @@ void ImageBitmapImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isol
     canvasModule->Set(context, ConvertToV8String(isolate, "ImageBitmap"), func);
 }
 
+
+void ImageBitmapImpl::FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto asset = args[0];
+    auto type = GetNativeType(asset);
+    auto isolate = args.GetIsolate();
+    if (type == NativeType::ImageAsset){
+        auto ptr = ImageAssetImpl::GetPointer(asset.As<v8::Object>());
+        auto ret = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto bitmap = new ImageBitmapImpl(ret);
+        auto data = v8::External::New(isolate, bitmap);
+        auto object = ImageBitmapImpl::NewInstance(isolate, data);
+        args.GetReturnValue().Set(object);
+        return;
+    }
+    args.GetReturnValue().SetNull();
+}
+
 ImageBitmapImpl *ImageBitmapImpl::GetPointer(v8::Local<v8::Object> object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
@@ -45,7 +62,10 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageBitmap"));
 
+    ctorTmpl->Set(ConvertToV8String(isolate, "fromAsset"), v8::FunctionTemplate::New(isolate, FromAsset));
+
     auto tmpl = ctorTmpl->InstanceTemplate();
+
     tmpl->SetInternalFieldCount(2);
     tmpl->SetAccessor(
             ConvertToV8String(isolate, "width"), GetWidth);
@@ -56,6 +76,13 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     tmpl->Set(
             ConvertToV8String(isolate, "close"), v8::FunctionTemplate::New(isolate, Close));
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "__getRef"),
+            v8::FunctionTemplate::New(isolate, GetReference));
 
     cache->ImageBitmapTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -93,6 +120,8 @@ void ImageBitmapImpl::Close(const v8::FunctionCallbackInfo<v8::Value> &args) {
         return;
     }
 
+    canvas_native_image_asset_close(ptr->GetImageAsset());
+
     ptr->closed_ = true;
 }
 
@@ -184,6 +213,34 @@ ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value>
     return ret;
 }
 
-ImageAsset* ImageBitmapImpl::GetImageAsset() {
+
+void
+ImageBitmapImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(ptr->GetImageAsset()));
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+ImageBitmapImpl::GetReference(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        auto isolate = args.GetIsolate();
+        auto reference = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(reference));
+        args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+
+    args.GetReturnValue().SetEmptyString();
+}
+
+const ImageAsset *ImageBitmapImpl::GetImageAsset() {
     return this->bitmap_;
 }

package/platforms/ios/src/cpp/ImageBitmapImpl.h

@@ -21,7 +21,7 @@ struct Options {
 
 class ImageBitmapImpl : public ObjectWrapperImpl {
 public:
-    explicit ImageBitmapImpl(ImageAsset *asset);
+    explicit ImageBitmapImpl(const ImageAsset *asset);
 
     ~ImageBitmapImpl();
 
@@ -30,11 +30,12 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = ImageBitmapImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::ImageBitmap);
 
         auto ptr = asset->Value();
         auto impl = static_cast<ObjectWrapperImpl *>(ptr);
 
+        SetNativeType(impl, NativeType::ImageBitmap);
+
 
         object->SetAlignedPointerInInternalField(0, ptr);
 
@@ -45,7 +46,7 @@ public:
 
     static Options HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options);
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -59,9 +60,16 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetReference(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
 private:
-    ImageAsset *bitmap_;
+    const ImageAsset *bitmap_;
     bool closed_ = false;
 };

package/platforms/ios/src/cpp/NativeType.h

@@ -0,0 +1,87 @@
+//
+// Created by Osei Fortune on 06/08/2024.
+//
+
+#ifndef CANVAS_ANDROID_NATIVETYPE_H
+#define CANVAS_ANDROID_NATIVETYPE_H
+
+enum class NativeType {
+    None,
+    CanvasGradient,
+    CanvasPattern,
+    ImageData,
+    ImageAsset,
+    CanvasRenderingContext2D,
+    WebGLRenderingContextBase,
+    Path2D,
+    Matrix,
+    ImageBitmap,
+    TextMetrics,
+
+    WebGLQuery,
+    WebGLProgram,
+    WebGLShader,
+    WebGLBuffer,
+    WebGLFramebuffer,
+    WebGLRenderbuffer,
+    WebGLTexture,
+    WebGLActiveInfo,
+    OES_fbo_render_mipmap,
+    EXT_blend_minmax,
+    EXT_color_buffer_half_float,
+    EXT_disjoint_timer_query,
+    EXT_sRGB,
+    EXT_shader_texture_lod,
+    EXT_texture_filter_anisotropic,
+    OES_element_index_uint,
+    OES_standard_derivatives,
+    OES_texture_float,
+    OES_texture_float_linear,
+    OES_texture_half_float_linear,
+    OES_texture_half_float,
+    WEBGL_color_buffer_float,
+    OES_vertex_array_object,
+    WebGLVertexArrayObject,
+    WEBGL_compressed_texture_atc,
+    WEBGL_compressed_texture_etc1,
+    WEBGL_compressed_texture_s3tc,
+    WEBGL_compressed_texture_s3tc_srgb,
+    WEBGL_compressed_texture_etc,
+    WEBGL_compressed_texture_pvrtc,
+    WEBGL_lose_context,
+    ANGLE_instanced_arrays,
+    WEBGL_depth_texture,
+    WEBGL_draw_buffers,
+    WebGLShaderPrecisionFormat,
+    WebGLUniformLocation,
+    WebGLSampler,
+    WebGLTransformFeedback,
+    WebGLSync,
+
+    GPUAdapter,
+    GPUSupportedLimits,
+    GPUDevice,
+    GPUQueue,
+    GPUBuffer,
+    GPUInstance,
+    GPUCanvasContext,
+    GPUTexture,
+    GPUAdapterInfo,
+    GPUCommandEncoder,
+    GPUComputePass,
+    GPUQuerySet,
+    GPUShaderModule,
+    GPUPipelineLayout,
+    GPURenderPipeline,
+    GPUBindGroupLayout,
+    GPUTextureView,
+    GPURenderPassEncoder,
+    GPUCommandBuffer,
+    GPUBindGroup,
+    GPUComputePipeline,
+    GPUSampler,
+    GPURenderBundleEncoder,
+    GPURenderBundle
+};
+
+#endif //CANVAS_ANDROID_NATIVETYPE_H

package/platforms/ios/src/cpp/ObjectWrapperImpl.h

@@ -9,9 +9,11 @@
 #define ObjectWrapperImpl_h
 
 #include "Common.h"
+#include "NativeType.h"
 
 class ObjectWrapperImpl {
 public:
+    NativeType type_ = NativeType::None;
 
     static void Finalizer(const v8::WeakCallbackInfo<ObjectWrapperImpl> &data) {
         auto *pThis = data.GetParameter();
@@ -25,6 +27,54 @@ public:
         weakHandle_.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
     }
 
+
+    /*
+    static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
+        if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
+            obj.As<v8::Object>()->InternalFieldCount() > 1) {
+            auto wrapper = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
+            if (wrapper != nullptr) {
+                ((ObjectWrapperImpl *) wrapper)->type_ = type;
+            }
+        }
+    }
+     */
+
+    inline static NativeType GetNativeType(const v8::Local<v8::Value> &obj) {
+        if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
+            obj.As<v8::Object>()->InternalFieldCount() > 1) {
+            auto info = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
+
+            if (info != nullptr) {
+                auto value = static_cast<ObjectWrapperImpl *>(info);
+                return value->type_;
+            }
+        }
+
+        return NativeType::None;
+    }
+
+    static void SetNativeType(ObjectWrapperImpl *obj, NativeType type) {
+        if (obj != nullptr) {
+            obj->type_ = type;
+        }
+    }
+
+    static NativeType GetNativeType(const ObjectWrapperImpl *obj) {
+        if (obj != nullptr) {
+            return obj->type_;
+        }
+        return NativeType::None;
+    }
+
+    static void SetNativeType(ObjectWrapperImpl &obj, NativeType type) {
+        obj.type_ = type;
+    }
+
+    static NativeType GetNativeType(const ObjectWrapperImpl &obj) {
+        return obj.type_;
+    }
+
 private:
     v8::Global<v8::Object> weakHandle_;
 

package/platforms/ios/src/cpp/PromiseCallback.h

@@ -0,0 +1,197 @@
+//
+// Created by Osei Fortune on 05/08/2024.
+//
+
+#pragma once
+
+#include "Common.h"
+#include <thread>
+
+#ifdef __ANDROID__
+
+#include <android/looper.h>
+#include <cassert>
+
+#endif
+
+#ifdef __APPLE__
+#include "NSOperationQueueWrapper.h"
+#endif
+
+
+#include <unistd.h>
+#include <fcntl.h>
+
+typedef void(*CompleteCallback)(bool success, void *data);
+
+#ifdef __APPLE__
+struct PromiseCallback {
+    struct Inner {
+        NSOperationQueueWrapper* current_queue = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        v8::Persistent<v8::Value> error_;
+        CompleteCallback completeCallback_;
+        CompleteCallback completeCallbackWrapper_;
+        bool isPrepared_ = false;
+        void* data;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+            this->completeCallbackWrapper_ = [](bool success, void *data){
+                if(data != nullptr){
+                    auto* callback = static_cast<PromiseCallback*>(data);
+                    auto inner = callback->inner_.get();
+                    if(inner == nullptr || inner->current_queue != nullptr){
+                        return;
+                    }
+
+                    inner->current_queue->addOperation([success, data, inner, callback](){
+                        inner->completeCallback_(success, data);
+                     //   delete callback;
+                    });
+                }
+            };
+        }
+
+        void prepare(){
+            current_queue = new NSOperationQueueWrapper(true);
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete, PromiseCallback* callback){
+           completeCallbackWrapper_(complete, callback);
+        }
+
+        ~Inner(){
+            callback_.Reset();
+            error_.Reset();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+    void prepare(){
+       auto inner = this->inner_.get();
+       if(inner == nullptr){return;}
+        inner->prepare();
+    }
+
+        void execute(bool complete) {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete, this);
+    }
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+};
+#endif
+
+#ifdef __ANDROID__
+
+struct PromiseCallback {
+    struct Inner {
+        int fd_[2];
+        ALooper *looper_ = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        void *data = nullptr;
+        CompleteCallback completeCallback_;
+        bool isPrepared_ = false;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+        }
+
+        void prepare() {
+            // release previous looper
+            if (isPrepared_) {
+                ALooper_removeFd(looper_, fd_[0]);
+                close(fd_[0]);
+                fd_[0] = -1;
+                fd_[1] = -1;
+                ALooper_release(looper_);
+            }
+
+            auto res = pipe(fd_);
+            assert(res != -1);
+            res = fcntl(fd_[1], F_SETFL, O_NONBLOCK);
+            assert(res != -1);
+            looper_ = ALooper_prepare(0);
+            ALooper_acquire(looper_);
+
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete) const {
+            if (!isPrepared_) { return; }
+            write(fd_[1],
+                  &complete,
+                  sizeof(bool));
+        }
+
+
+        ~Inner() {
+            if (!isPrepared_) {
+                return;
+            }
+            ALooper_removeFd(looper_, fd_[0]);
+            close(fd_[0]);
+            ALooper_release(looper_);
+            callback_.Reset();
+        }
+    };
+
+    void prepare() const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->prepare();
+        auto looper = inner->looper_;
+        auto fd = inner->fd_[0];
+        auto data = new PromiseCallback(this->inner_);
+        ALooper_addFd(looper,
+                      fd,
+                      0,
+                      ALOOPER_EVENT_INPUT,
+                      [](int fd, int events,
+                         void *data) {
+                          auto cb = static_cast<PromiseCallback *>(data);
+                          bool done = false;
+                          read(fd, &done,
+                               sizeof(bool));
+                          cb->inner_->completeCallback_(done, data);
+                          return 0;
+                      }, (void *) data);
+
+        inner->isPrepared_ = true;
+    }
+
+    void execute(bool complete) const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete);
+    }
+
+    std::shared_ptr<Inner> inner_;
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+
+};
+
+#endif