@nativescript/canvas 2.0.0-alpha.1 → 2.0.0-alpha.11

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

@@ -0,0 +1,63 @@
+//
+// Created by Osei Fortune on 25/02/2023.
+//
+
+#pragma once
+
+#include <memory>
+#include "rust/cxx.h"
+#import <NativeScript/JSIRuntime.h>
+
+using namespace facebook;
+
+inline static int64_t getPointerValue(jsi::Runtime &runtime, const facebook::jsi::Value &value) {
+    return value.asBigInt(runtime).Int64Value(runtime);
+}
+
+template<typename T>
+inline static rust::Slice<T>
+GetArrayBufferData(jsi::Runtime &runtime, facebook::jsi::ArrayBuffer &array) {
+    auto buf = array.data(runtime);
+    auto size = array.size(runtime);
+
+    rust::Slice<T> slice(reinterpret_cast<T *>(buf), size);
+    return std::move(slice);
+}
+
+template<typename T>
+inline static rust::Slice<T>
+GetTypedArrayData(jsi::Runtime &runtime, facebook::jsi::TypedArray &array) {
+    auto buf = array.data(runtime);
+    auto offset = array.offset(runtime);
+    auto size = array.size(runtime);
+
+    auto data = buf + offset;
+
+    rust::Slice<T> slice(reinterpret_cast<T *>(data), (size / sizeof(T)));
+    return std::move(slice);
+}
+
+template<typename T>
+inline static std::shared_ptr<T>
+getHostObject(jsi::Runtime &runtime, const facebook::jsi::Value &value) {
+    if (value.isObject()) {
+        auto valueObject = value.asObject(runtime);
+        try {
+            if (valueObject.template isHostObject(runtime)) {
+                return valueObject.template asHostObject<T>(runtime);
+            }
+        } catch (...) {}
+    }
+
+    return nullptr;
+}
+
+template<typename T>
+inline static std::shared_ptr<T>
+getHostObject(jsi::Runtime &runtime, const facebook::jsi::Object &value) {
+    if (value.template isHostObject(runtime)) {
+        return value.template asHostObject<T>(runtime);
+    }
+    return nullptr;
+}
+

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

@@ -0,0 +1,30 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#include <unistd.h>
+#include <thread>
+#include <NativeScript/JSIRuntime.h>
+#include <vector>
+
+using namespace org::nativescript::canvas;
+
+using namespace facebook;
+
+class JSI_EXPORT ImageAssetImpl : public jsi::HostObject {
+public:
+    ImageAssetImpl(rust::Box<ImageAsset> asset);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    ImageAsset &GetImageAsset();
+
+private:
+    rust::Box<ImageAsset> asset_;
+};

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

@@ -0,0 +1,417 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "ImageAssetImpl.h"
+#include <string>
+#include "JSICallback.h"
+
+
+
+ImageAssetImpl::ImageAssetImpl(rust::Box<ImageAsset> asset)
+: asset_(std::move(asset)) {
+}
+
+std::vector<jsi::PropNameID> ImageAssetImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(12);
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("width")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("height")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("error")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("scale")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromUrlSync")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromUrlCb")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromFileSync")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromFileCb")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromBytesSync")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fromBytesCb")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("saveSync")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("saveCb")));
+    return ret;
+}
+
+jsi::Value ImageAssetImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "width") {
+        return {(double) canvas_native_image_asset_width(this->GetImageAsset())};
+    } else if (methodName == "height") {
+        return {(double) canvas_native_image_asset_height(this->GetImageAsset())};
+    } else if (methodName == "error") {
+        auto error = canvas_native_image_asset_get_error(this->GetImageAsset());
+        return jsi::String::createFromAscii(runtime, error.data(), error.size());
+    } else if (methodName == "scale") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            if (count > 1) {
+                auto x = (uint32_t) arguments[0].asNumber();
+                auto y = (uint32_t) arguments[1].asNumber();
+                if (x > 0 && y > 0) {
+                    canvas_native_image_asset_scale(
+                                                    this->GetImageAsset(), x,
+                                                    y);
+                }
+            }
+            
+            
+            return jsi::Value::undefined();
+        }
+                                                     );
+    } else if (methodName == "fromUrlSync") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     1,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            
+            auto url = arguments[0].asString(
+                                             runtime).utf8(runtime);
+            auto done = canvas_native_image_asset_load_from_url(
+                                                                this->GetImageAsset(),
+                                                                rust::Str(url.c_str()));
+            return {done};
+        }
+                                                     );
+    } else if (methodName == "fromUrlCb") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            
+            auto current_queue = NSOperationQueue.currentQueue;
+            
+            if (count < 2) {
+                return jsi::Value::undefined();
+            }
+            
+            
+            auto url = arguments[0].asString(
+                                             runtime).utf8(runtime);
+            
+            auto asset = canvas_native_image_asset_shared_clone(
+                                                                this->GetImageAsset());
+            
+            auto cb = std::make_shared<jsi::Value>(
+                                                   runtime, arguments[1]);
+            
+            
+            auto jsi_callback = new JSICallback(
+                                                std::shared_ptr<jsi::Value>(
+                                                                            cb));
+            
+            
+            auto queue = [NSOperationQueue new];
+            [queue addOperationWithBlock:^{
+                rust::Str asset_url(url.c_str());
+                
+                auto asset = canvas_native_image_asset_shared_clone(
+                                                                    this->GetImageAsset());
+                
+                auto done = canvas_native_image_asset_load_from_url(
+                                                                    this->GetImageAsset(), asset_url
+                                                                    );
+                [current_queue addOperationWithBlock:^{
+                    
+                    
+                    
+                    
+                    auto func = jsi_callback->value_->asObject(
+                                                               runtime).asFunction(
+                                                                                   runtime);
+                    
+                    
+                    
+                    func.call(runtime,
+                              jsi::Value(
+                                         done));
+                    
+                    delete static_cast<JSICallback *>(jsi_callback);
+                }];
+            }];
+            return jsi::Value::undefined();
+        }
+                                                     );
+    } else if (methodName == "fromFileSync") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     1,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            
+            
+            auto path = arguments[0].asString(
+                                              runtime).utf8(runtime);
+            
+            auto done = canvas_native_image_asset_load_from_path(
+                                                                 this->GetImageAsset(),
+                                                                 rust::Str(path.c_str()));
+            
+            return {done};
+        }
+                                                     );
+    } else if (methodName == "fromFileCb") {
+        auto current_queue = NSOperationQueue.currentQueue;
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this, current_queue](jsi::Runtime &runtime,
+                                                                           const jsi::Value &thisValue,
+                                                                           const jsi::Value *arguments,
+                                                                           size_t count) -> jsi::Value {
+            
+            
+            auto path = arguments[0].asString(
+                                              runtime).utf8(runtime);
+            
+            
+            
+            auto cb = std::make_shared<jsi::Value>(
+                                                   runtime, arguments[1]);
+            
+            
+            auto jsi_callback = new JSICallback(
+                                                std::shared_ptr<jsi::Value>(
+                                                                            cb));
+            
+            
+            
+            
+            auto queue = [NSOperationQueue new];
+            [queue addOperationWithBlock:^{
+                rust::Str asset_path(path.c_str());
+                
+                auto asset = canvas_native_image_asset_shared_clone(
+                                                                    this->GetImageAsset());
+                
+                auto done = canvas_native_image_asset_load_from_path(
+                                                                     this->GetImageAsset(), asset_path
+                                                                     );
+                [current_queue addOperationWithBlock:^{
+                    
+                    
+                    
+                    
+                    auto func = jsi_callback->value_->asObject(
+                                                               runtime).asFunction(
+                                                                                   runtime);
+                    
+                    
+                    
+                    func.call(runtime,
+                              jsi::Value(
+                                         done));
+                    
+                    delete static_cast<JSICallback *>(jsi_callback);
+                }];
+            }];
+            
+            
+            return jsi::Value::undefined();
+        }
+                                                     );
+    } else if (methodName == "fromBytesSync") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     1,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            
+            
+            if (arguments[0].isObject()) {
+                auto object = arguments[0].asObject(
+                                                    runtime);
+                if (!object.isArrayBuffer(
+                                          runtime)) { return {false}; }
+                auto buf = object.getArrayBuffer(
+                                                 runtime);
+                
+                auto size = buf.size(runtime);
+                auto data = buf.data(runtime);
+                auto done = canvas_native_image_asset_load_from_raw(
+                                                                    this->GetImageAsset(),
+                                                                    rust::Slice<const uint8_t>(
+                                                                                               data, size));
+                return {done};
+            }
+            return {false};
+        }
+                                                     );
+    } else if (methodName == "fromBytesCb") {
+        auto current_queue = NSOperationQueue.currentQueue;
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this, current_queue](jsi::Runtime &runtime,
+                                                                           const jsi::Value &thisValue,
+                                                                           const jsi::Value *arguments,
+                                                                           size_t count) -> jsi::Value {
+            
+            
+            auto bytes = arguments[0].asObject(
+                                               runtime).getArrayBuffer(runtime);
+            
+            auto size = bytes.size(runtime);
+            auto data = bytes.data(runtime);
+            auto buf = rust::Slice<const uint8_t>(data,
+                                                  size);
+            
+            auto asset = canvas_native_image_asset_shared_clone(
+                                                                this->GetImageAsset());
+            
+            
+            auto cb = std::make_shared<jsi::Value>(
+                                                   runtime, arguments[1]);
+            
+            auto jsi_callback = new JSICallback(
+                                                std::shared_ptr<jsi::Value>(
+                                                                            cb));
+            
+            
+            auto queue = [NSOperationQueue new];
+            [queue addOperationWithBlock:^{
+                
+                auto asset = canvas_native_image_asset_shared_clone(
+                                                                    this->GetImageAsset());
+                
+                
+                
+                
+                auto done = canvas_native_image_asset_load_from_raw(
+                                                                    this->GetImageAsset(), buf);
+                
+                [current_queue addOperationWithBlock:^{
+                    
+                    
+                    
+                    
+                    auto func = jsi_callback->value_->asObject(
+                                                               runtime).asFunction(
+                                                                                   runtime);
+                    
+                    
+                    
+                    func.call(runtime,
+                              jsi::Value(
+                                         done));
+                    
+                    delete static_cast<JSICallback *>(jsi_callback);
+                }];
+            }];
+            
+            return jsi::Value::undefined();
+        }
+                                                     );
+    } else if (methodName == "saveSync") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+            
+            if (count < 2) {
+                return {false};
+            }
+            
+            auto path = arguments[0].asString(
+                                              runtime).utf8(runtime);
+            auto format = (uint32_t) arguments[1].asNumber();
+            auto done = canvas_native_image_asset_save_path(
+                                                            this->GetImageAsset(),
+                                                            rust::Str(path.c_str()), format);
+            
+            return {done};
+        }
+                                                     );
+    } else if (methodName == "saveCb") {
+        auto current_queue = NSOperationQueue.currentQueue;
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     3,
+                                                     [this, current_queue](jsi::Runtime &runtime,
+                                                                           const jsi::Value &thisValue,
+                                                                           const jsi::Value *arguments,
+                                                                           size_t count) -> jsi::Value {
+            
+            
+            auto path = arguments[0].asString(
+                                              runtime).utf8(runtime);
+            
+            auto format = (uint32_t) arguments[1].asNumber();
+            
+            
+            auto asset = canvas_native_image_asset_shared_clone(
+                                                                this->GetImageAsset());
+            
+            
+            auto cb = std::make_shared<jsi::Value>(
+                                                   runtime, arguments[1]);
+            
+            auto jsi_callback = new JSICallback(
+                                                std::shared_ptr<jsi::Value>(
+                                                                            cb));
+            
+            
+            auto queue = [NSOperationQueue new];
+            [queue addOperationWithBlock:^{
+                
+                rust::Str asset_path(
+                                     path.c_str());
+                
+                
+                auto asset = canvas_native_image_asset_shared_clone(
+                                                                    this->GetImageAsset());
+                
+                
+                auto done = canvas_native_image_asset_save_path(
+                                                                this->GetImageAsset(),
+                                                                asset_path,
+                                                                format);
+                
+                
+                
+                [current_queue addOperationWithBlock:^{
+                    
+                    
+                    
+                    
+                    auto func = jsi_callback->value_->asObject(
+                                                               runtime).asFunction(
+                                                                                   runtime);
+                    
+                    
+                    
+                    func.call(runtime,
+                              jsi::Value(
+                                         done));
+                    
+                    delete static_cast<JSICallback *>(jsi_callback);
+                }];
+            }];
+            
+            return jsi::Value::undefined();
+        }
+                                                     );
+    }
+    
+    return jsi::Value::undefined();
+    
+}
+
+ImageAsset &ImageAssetImpl::GetImageAsset() {
+    return *this->asset_;
+}

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

@@ -0,0 +1,41 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#include "Helpers.h"
+#import <NativeScript/JSIRuntime.h>
+#include <vector>
+using namespace org::nativescript::canvas;
+
+struct Options {
+    bool flipY = false;
+    ImageBitmapPremultiplyAlpha premultiplyAlpha = ImageBitmapPremultiplyAlpha::Default;
+    ImageBitmapColorSpaceConversion colorSpaceConversion = ImageBitmapColorSpaceConversion::Default;
+    ImageBitmapResizeQuality resizeQuality = ImageBitmapResizeQuality::Low;
+    float resizeWidth = 0;
+    float resizeHeight = 0;
+};
+
+
+using namespace facebook;
+
+class JSI_EXPORT ImageBitmapImpl : public jsi::HostObject {
+public:
+    ImageBitmapImpl(rust::Box<ImageAsset> asset);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    static Options HandleOptions(jsi::Runtime &runtime, const jsi::Value &options);
+
+    ImageAsset &GetImageAsset();
+
+private:
+    rust::Box<ImageAsset> bitmap_;
+    bool closed_ = false;
+};

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

@@ -0,0 +1,126 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "ImageBitmapImpl.h"
+#include "ImageAssetImpl.h"
+#include "rust/cxx.h"
+
+ImageBitmapImpl::ImageBitmapImpl(rust::Box<ImageAsset> asset)
+        : bitmap_(std::move(asset)) {}
+
+jsi::Value ImageBitmapImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "width") {
+        if (this->closed_) {
+            return {0};
+        }
+        return {(int32_t) canvas_native_image_asset_width(this->GetImageAsset())};
+    } else if (methodName == "height") {
+        if (this->closed_) {
+            return {0};
+        }
+        return {(int32_t) canvas_native_image_asset_height(this->GetImageAsset())};
+    } else if (methodName == "close") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     0,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+                                                         this->closed_ = true;
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+    }
+    return jsi::Value::undefined();
+}
+
+
+std::vector<jsi::PropNameID> ImageBitmapImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(3);
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("width")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("height")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("close")));
+    return ret;
+}
+
+
+Options
+ImageBitmapImpl::HandleOptions(jsi::Runtime &runtime, const jsi::Value &options) {
+    Options ret;
+
+    if (options.isObject()) {
+        auto config = options.asObject(runtime);
+
+
+        auto flipYValue = config.getProperty(runtime, "flipY");
+        if (flipYValue.isBool()) {
+            ret.flipY = flipYValue.asBool();
+        }
+
+        auto premultiplyAlphaValue = config.getProperty(runtime, "premultiplyAlpha");
+
+        if (premultiplyAlphaValue.isString()) {
+            auto premultiplyAlpha = premultiplyAlphaValue.asString(runtime).utf8(runtime);
+
+            if (premultiplyAlpha == "premultiply") {
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlpha::Premultiply;
+            }
+
+            if (premultiplyAlpha == "none") {
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlpha::None;
+            }
+        }
+
+        auto colorSpaceConversionValue = config.getProperty(runtime, "colorSpaceConversion");
+
+        if (colorSpaceConversionValue.isString()) {
+            auto colorSpaceConversion = colorSpaceConversionValue.asString(runtime).utf8(runtime);
+
+            if (colorSpaceConversion == "none") {
+                ret.colorSpaceConversion = ImageBitmapColorSpaceConversion::None;
+            }
+        }
+
+        auto resizeQualityValue = config.getProperty(runtime, "resizeQuality");
+
+        if (resizeQualityValue.isString()) {
+            auto resizeQuality = resizeQualityValue.asString(runtime).utf8(runtime);
+
+            if (resizeQuality == "medium") {
+                ret.resizeQuality = ImageBitmapResizeQuality::Medium;
+            }
+
+            if (resizeQuality == "high") {
+                ret.resizeQuality = ImageBitmapResizeQuality::High;
+            }
+
+            if (resizeQuality == "pixelated") {
+                ret.resizeQuality = ImageBitmapResizeQuality::Pixelated;
+            }
+        }
+
+        auto resizeWidthValue = config.getProperty(runtime, "resizeWidth");
+
+        if (resizeWidthValue.isNumber()) {
+            auto val = resizeWidthValue.asNumber();
+            ret.resizeWidth = (float) val;
+        }
+
+        auto resizeHeightValue = config.getProperty(runtime, "resizeHeight");
+
+        if (resizeHeightValue.isNumber()) {
+            auto val = resizeHeightValue.asNumber();
+            ret.resizeHeight = (float) val;
+        }
+    }
+
+    return ret;
+}
+
+ImageAsset &ImageBitmapImpl::GetImageAsset() {
+    return *this->bitmap_;
+}