@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

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

@@ -9,23 +9,25 @@
 #include <vector>
 #include "Helpers.h"
 #include "Common.h"
+
 #ifdef __APPLE__
 #include "NSOperationQueueWrapper.h"
 #endif
+
 #include "ObjectWrapperImpl.h"
 
-class ImageAssetImpl: ObjectWrapperImpl{
+class ImageAssetImpl : ObjectWrapperImpl {
 public:
 
-    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);
 
-    static ImageAssetImpl *GetPointer(const v8::Local<v8::Object>& object);
+    static ImageAssetImpl *GetPointer(const v8::Local<v8::Object> &object);
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
@@ -38,12 +40,14 @@ public:
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void GetAddr(v8::Local<v8::String> name,
-                         const v8::PropertyCallbackInfo<v8::Value> &info);
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetReference(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void GetError(v8::Local<v8::String> name,
-                          const v8::PropertyCallbackInfo<v8::Value> &info);
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    static void Scale(const v8::FunctionCallbackInfo<v8::Value> &args);
+//    static void Scale(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void FromUrlSync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
@@ -57,11 +61,15 @@ public:
 
     static void FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    static void SaveSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void FromEncodedBytesSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromEncodedBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    /* static void SaveSync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    static void SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+     static void SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args);*/
 
 
 private:
-    ImageAsset* asset_;
+    const ImageAsset *asset_;
 };

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

@@ -5,11 +5,11 @@
 #include "ImageBitmapImpl.h"
 #include "Caches.h"
 
-ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+ImageBitmapImpl::ImageBitmapImpl(const ImageAsset *asset)
         : bitmap_(asset) {}
 
-ImageBitmapImpl::~ImageBitmapImpl(){
-    canvas_native_image_asset_destroy(bitmap_);
+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;
 }
 
@@ -121,11 +150,11 @@ ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value>
             auto premultiplyAlpha = ConvertFromV8String(isolate, premultiplyAlphaValue);
 
             if (premultiplyAlpha == "premultiply") {
-                ret.premultiplyAlpha = ImageBitmapPremultiplyAlphaPremultiply;
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlpha::ImageBitmapPremultiplyAlphaPremultiply;
             }
 
             if (premultiplyAlpha == "none") {
-                ret.premultiplyAlpha = ImageBitmapPremultiplyAlphaNone;
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlpha::ImageBitmapPremultiplyAlphaAlphaNone;
             }
         }
 
@@ -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:
-    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/JSIReadFileCallback.h

@@ -38,9 +38,9 @@ struct JSIReadFileCallback {
 
     ~JSIReadFileCallback() {
         callback_.Reset();
-        canvas_native_u8_buffer_destroy(data_);
+        canvas_native_u8_buffer_release(data_);
         data_ = nullptr;
-        
+
         canvas_native_string_destroy(error_);
         error_ = nullptr;
     }
@@ -86,9 +86,9 @@ struct JSIReadFileCallback {
         close(fd_[0]);
         ALooper_release(looper_);
         callback_.Reset();
-        canvas_native_u8_buffer_destroy(data_);
+        canvas_native_u8_buffer_release(data_);
         data_ = nullptr;
-        
+
         canvas_native_string_destroy(error_);
         error_ = nullptr;
     }

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/OneByteStringResource.cpp

@@ -27,11 +27,11 @@ OneByteStringResource::OneByteStringResource(std::string string) : stdString_(st
 
 OneByteStringResource::~OneByteStringResource() {
     if (usingBuffer_) {
-        canvas_native_u8_buffer_destroy(buffer_);
+        canvas_native_u8_buffer_release(buffer_);
         this->string_ = nullptr;
         this->length_ = 0;
     }else if(usingCow_){
-        canvas_native_ccow_destroy(cow_);
+        canvas_native_ccow_release(cow_);
         this->string_ = nullptr;
         this->length_ = 0;
     }else if(usingString){

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

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

@@ -12,9 +12,9 @@
 class RafImpl {
 public:
     RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf);
-    
+
     ~RafImpl(){
-        canvas_native_raf_destroy(this->GetRaf());
+        canvas_native_raf_release(this->GetRaf());
         this->raf_ = nullptr;
         delete rafCallback_;
     }

package/platforms/ios/src/cpp/TextDecoderImpl.cpp

@@ -57,12 +57,6 @@ v8::Local<v8::FunctionTemplate> TextDecoderImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
-void MyWeakCallback(const v8::WeakCallbackInfo<TextDecoderImpl>& info) {
-    TextDecoderImpl* obj = info.GetParameter();
-    // Perform cleanup or any necessary actions when the object is no longer reachable
-    delete obj;
-}
-
 void TextDecoderImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto count = args.Length();
     auto value = args[0];

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

@@ -10,11 +10,11 @@
 
 class TextDecoderImpl: ObjectWrapperImpl {
 public:
-  
-    TextDecoderImpl(TextDecoder *decoder);
+
+    explicit TextDecoderImpl(TextDecoder *decoder);
 
     ~TextDecoderImpl() {
-        canvas_native_text_decoder_destroy(this->GetTextDecoder());
+        canvas_native_text_decoder_release(this->GetTextDecoder());
         this->decoder_ = nullptr;
     }
 

package/platforms/ios/src/cpp/TextEncoderImpl.cpp

@@ -122,7 +122,7 @@ void TextEncoderImpl::Encode(const v8::FunctionCallbackInfo<v8::Value> &args) {
                                                   [](void *data, size_t length,
                                                      void *deleter_data) {
                                                       if (deleter_data != nullptr) {
-                                                          canvas_native_u8_buffer_destroy((U8Buffer *)deleter_data);
+                                                          canvas_native_u8_buffer_release((U8Buffer *)deleter_data);
                                                       }
                                                   },
                                                   encoded);