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

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.h

@@ -0,0 +1,29 @@
+//
+// Created by Osei Fortune on 27/03/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import "NativeScript/JSIRuntime.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT ImageDataImpl : public jsi::HostObject {
+public:
+    ImageDataImpl(rust::Box<ImageData> imageData);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    ImageData &GetImageData() {
+        return *this->imageData_;
+    }
+
+private:
+    rust::Box<ImageData> imageData_;
+};

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.mm

@@ -0,0 +1,68 @@
+//
+// Created by Osei Fortune on 27/03/2022.
+//
+
+#include "ImageDataImpl.h"
+
+
+struct ImageDataBuffer : jsi::MutableBuffer {
+public:
+    explicit ImageDataBuffer(rust::Box<ImageData> imageData) : imageData_(std::move(imageData)) {
+        auto slice = canvas_native_image_data_get_data(*this->imageData_);
+        this->buf_ = slice.data();
+        this->size_ = slice.size();
+    }
+
+    size_t size() const override {
+        return this->size_;
+    }
+
+    uint8_t *data() override {
+        return this->buf_;
+    }
+
+    ~ImageDataBuffer() override {
+        this->buf_ = nullptr;
+    }
+
+private:
+    uint8_t *buf_;
+    size_t size_;
+    rust::Box<ImageData> imageData_;
+};
+
+ImageDataImpl::ImageDataImpl(rust::Box<ImageData> imageData) : imageData_(std::move(imageData)) {}
+
+std::vector<jsi::PropNameID> ImageDataImpl::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("data")));
+    return ret;
+}
+
+jsi::Value ImageDataImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "width") {
+        return {canvas_native_image_data_get_width(this->GetImageData())};
+    } else if (methodName == "height") {
+        return {canvas_native_image_data_get_height(this->GetImageData())};
+    } else if (methodName == "data") {
+        auto buf = std::make_shared<ImageDataBuffer>(
+                canvas_native_image_data_get_shared_instance(this->GetImageData()));
+
+        auto ab = jsi::ArrayBuffer(runtime, buf);
+
+
+        auto Uint8ClampedArray = runtime.global()
+                .getProperty(runtime,
+                             "Uint8ClampedArray")
+                .asObject(runtime)
+                .asFunction(runtime);
+
+        return Uint8ClampedArray.callAsConstructor(
+                runtime, ab);
+    }
+    return jsi::Value::undefined();
+}

package/platforms/ios/src/cpp/canvas2d/MatrixImpl.h

@@ -0,0 +1,29 @@
+//
+// Created by Osei Fortune on 03/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import "NativeScript/JSIRuntime.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT MatrixImpl : public jsi::HostObject {
+public:
+    MatrixImpl(rust::Box<Matrix> matrix);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    Matrix &GetMatrix();
+
+private:
+    rust::Box<Matrix> matrix_;
+};

package/platforms/ios/src/cpp/canvas2d/MatrixImpl.mm

@@ -0,0 +1,149 @@
+//
+// Created by Osei Fortune on 03/04/2022.
+//
+
+#include "MatrixImpl.h"
+
+
+MatrixImpl::MatrixImpl(rust::Box<Matrix> matrix) : matrix_(std::move(matrix)) {}
+
+std::vector<jsi::PropNameID> MatrixImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(22);
+
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("a")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("b")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("c")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("d")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("e")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("f")));
+
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m11")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m12")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m13")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m14")));
+
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m21")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m22")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m23")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m24")));
+
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m31")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m32")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m33")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m34")));
+
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m41")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m42")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m43")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("m44")));
+
+
+    return ret;
+}
+
+jsi::Value MatrixImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "a") {
+        return {(double) canvas_native_matrix_get_a(this->GetMatrix())};
+    } else if (methodName == "b") {
+        return {(double) canvas_native_matrix_get_b(this->GetMatrix())};
+    } else if (methodName == "c") {
+        return {(double) canvas_native_matrix_get_c(this->GetMatrix())};
+    } else if (methodName == "d") {
+        return {(double) canvas_native_matrix_get_d(this->GetMatrix())};
+    } else if (methodName == "e") {
+        return {(double) canvas_native_matrix_get_e(this->GetMatrix())};
+    } else if (methodName == "f") {
+        return {(double) canvas_native_matrix_get_f(this->GetMatrix())};
+    } else if (methodName == "m11") {
+        return {(double) canvas_native_matrix_get_m11(this->GetMatrix())};
+    } else if (methodName == "m12") {
+        return {(double) canvas_native_matrix_get_m12(this->GetMatrix())};
+    } else if (methodName == "m13") {
+        return {(double) canvas_native_matrix_get_m13(this->GetMatrix())};
+    } else if (methodName == "m14") {
+        return {(double) canvas_native_matrix_get_m14(this->GetMatrix())};
+    } else if (methodName == "m21") {
+        return {(double) canvas_native_matrix_get_m21(this->GetMatrix())};
+    } else if (methodName == "m22") {
+        return {(double) canvas_native_matrix_get_m22(this->GetMatrix())};
+    } else if (methodName == "m23") {
+        return {(double) canvas_native_matrix_get_m23(this->GetMatrix())};
+    } else if (methodName == "m24") {
+        return {(double) canvas_native_matrix_get_m24(this->GetMatrix())};
+    } else if (methodName == "m31") {
+        return {(double) canvas_native_matrix_get_m31(this->GetMatrix())};
+    } else if (methodName == "m32") {
+        return {(double) canvas_native_matrix_get_m32(this->GetMatrix())};
+    } else if (methodName == "m33") {
+        return {(double) canvas_native_matrix_get_m33(this->GetMatrix())};
+    } else if (methodName == "m34") {
+        return {(double) canvas_native_matrix_get_m34(this->GetMatrix())};
+    } else if (methodName == "m41") {
+        return {(double) canvas_native_matrix_get_m41(this->GetMatrix())};
+    } else if (methodName == "m42") {
+        return {(double) canvas_native_matrix_get_m42(this->GetMatrix())};
+    } else if (methodName == "m43") {
+        return {(double) canvas_native_matrix_get_m43(this->GetMatrix())};
+    } else if (methodName == "m44") {
+        return {(double) canvas_native_matrix_get_m44(this->GetMatrix())};
+    }
+
+    return jsi::Value::undefined();
+}
+
+void MatrixImpl::set(jsi::Runtime &runtime, const jsi::PropNameID &name, const jsi::Value &value) {
+    auto methodName = name.utf8(runtime);
+    if (!value.isNumber()) { return; }
+    auto val = (float) value.asNumber();
+    if (methodName == "a") {
+        canvas_native_matrix_set_a(this->GetMatrix(), val);
+    } else if (methodName == "b") {
+        canvas_native_matrix_set_b(this->GetMatrix(), val);
+    } else if (methodName == "c") {
+        canvas_native_matrix_set_c(this->GetMatrix(), val);
+    } else if (methodName == "d") {
+        canvas_native_matrix_set_d(this->GetMatrix(), val);
+    } else if (methodName == "e") {
+        canvas_native_matrix_set_e(this->GetMatrix(), val);
+    } else if (methodName == "f") {
+        canvas_native_matrix_set_f(this->GetMatrix(), val);
+    } else if (methodName == "m11") {
+        canvas_native_matrix_set_m11(this->GetMatrix(), val);
+    } else if (methodName == "m12") {
+        canvas_native_matrix_set_m12(this->GetMatrix(), val);
+    } else if (methodName == "m13") {
+        canvas_native_matrix_set_m13(this->GetMatrix(), val);
+    } else if (methodName == "m14") {
+        canvas_native_matrix_set_m14(this->GetMatrix(), val);
+    } else if (methodName == "m21") {
+        canvas_native_matrix_set_m21(this->GetMatrix(), val);
+    } else if (methodName == "m22") {
+        canvas_native_matrix_set_m22(this->GetMatrix(), val);
+    } else if (methodName == "m23") {
+        canvas_native_matrix_set_m23(this->GetMatrix(), val);
+    } else if (methodName == "m24") {
+        canvas_native_matrix_set_m24(this->GetMatrix(), val);
+    } else if (methodName == "m31") {
+        canvas_native_matrix_set_m31(this->GetMatrix(), val);
+    } else if (methodName == "m32") {
+        canvas_native_matrix_set_m32(this->GetMatrix(), val);
+    } else if (methodName == "m33") {
+        canvas_native_matrix_set_m33(this->GetMatrix(), val);
+    } else if (methodName == "m34") {
+        canvas_native_matrix_set_m34(this->GetMatrix(), val);
+    } else if (methodName == "m41") {
+        canvas_native_matrix_set_m41(this->GetMatrix(), val);
+    } else if (methodName == "m42") {
+        canvas_native_matrix_set_m42(this->GetMatrix(), val);
+    } else if (methodName == "m43") {
+        canvas_native_matrix_set_m43(this->GetMatrix(), val);
+    } else if (methodName == "m44") {
+        canvas_native_matrix_set_m44(this->GetMatrix(), val);
+    }
+}
+
+Matrix &MatrixImpl::GetMatrix() {
+    return *this->matrix_;
+}

package/platforms/ios/src/cpp/canvas2d/Path2D.h

@@ -0,0 +1,27 @@
+//
+// Created by Osei Fortune on 28/03/2022.
+//
+
+#pragma once
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import "NativeScript/JSIRuntime.h"
+#include "Helpers.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT Path2D : public jsi::HostObject {
+public:
+    Path2D(rust::Box<Path> path);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    Path &GetPath();
+
+private:
+    rust::Box<Path> path_;
+};

package/platforms/ios/src/cpp/canvas2d/Path2D.mm

@@ -0,0 +1,335 @@
+//
+// Created by Osei Fortune on 28/03/2022.
+//
+
+#include "Path2D.h"
+
+
+Path2D::Path2D(rust::Box<Path> path)
+        : path_(std::move(path)) {}
+
+std::vector<jsi::PropNameID> Path2D::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(11);
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("addPath")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("arc")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("arcTo")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bezierCurveTo")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("closePath")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("ellipse")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("lineTo")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("moveTo")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("quadraticCurveTo")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("rect")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("roundRect")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("__toSVG")));
+    return ret;
+}
+
+jsi::Value Path2D::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "addPath") {
+        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 object = getHostObject<Path2D>(
+                                                                 runtime, arguments[0]);
+                                                         if (object != nullptr) {
+                                                             canvas_native_path_add_path(
+                                                                     this->GetPath(),
+                                                                     object->GetPath());
+                                                         }
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+    } else if (methodName == "arc") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     6,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         auto anti_clockwise = false;
+                                                         if (count == 6) {
+                                                             anti_clockwise = arguments[5].asBool();
+                                                         }
+
+                                                         canvas_native_path_arc(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber()),
+                                                                 static_cast<float>(arguments[4].asNumber()),
+                                                                 anti_clockwise
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "arcTo") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     5,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         canvas_native_path_arc_to(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber()),
+                                                                 static_cast<float>(arguments[4].asNumber())
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "bezierCurveTo") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     6,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         canvas_native_path_bezier_curve_to(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber()),
+                                                                 static_cast<float>(arguments[4].asNumber()),
+                                                                 static_cast<float>(arguments[5].asNumber())
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "closePath") {
+        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 {
+
+
+                                                         canvas_native_path_close_path(
+                                                                 this->GetPath());
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "ellipse") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     7,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         auto anti_clockwise = false;
+                                                         if (count > 7) {
+                                                             anti_clockwise = arguments[7].asBool();
+                                                         }
+                                                         canvas_native_path_ellipse(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber()),
+                                                                 static_cast<float>(arguments[4].asNumber()),
+                                                                 static_cast<float>(arguments[5].asNumber()),
+                                                                 static_cast<float>(arguments[6].asNumber()),
+                                                                 anti_clockwise
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "lineTo") {
+        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 {
+
+
+                                                         canvas_native_path_line_to(this->GetPath(),
+                                                                                    static_cast<float>(arguments[0].asNumber()),
+                                                                                    static_cast<float>(arguments[1].asNumber()));
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "moveTo") {
+        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 {
+
+
+                                                         canvas_native_path_move_to(this->GetPath(),
+                                                                                    static_cast<float>(arguments[0].asNumber()),
+                                                                                    static_cast<float>(arguments[1].asNumber()));
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "quadraticCurveTo") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     4,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         canvas_native_path_quadratic_curve_to(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber())
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "rect") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     4,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+
+                                                         canvas_native_path_rect(
+                                                                 this->GetPath(),
+                                                                 static_cast<float>(arguments[0].asNumber()),
+                                                                 static_cast<float>(arguments[1].asNumber()),
+                                                                 static_cast<float>(arguments[2].asNumber()),
+                                                                 static_cast<float>(arguments[3].asNumber())
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+
+    } else if (methodName == "roundRect") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     4,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+                                                         if (count == 5) {
+                                                             auto x = static_cast<float>(arguments[0].asNumber());
+                                                             auto y = static_cast<float>(arguments[1].asNumber());
+                                                             auto width = static_cast<float>(arguments[2].asNumber());
+                                                             auto height = static_cast<float>(arguments[3].asNumber());
+                                                             if (arguments[4].isObject()) {
+                                                                 auto radii = arguments[4].asObject(
+                                                                         runtime);
+                                                                 if (radii.isArray(runtime)) {
+                                                                     auto array = radii.getArray(
+                                                                             runtime);
+                                                                     auto size = array.size(
+                                                                             runtime);
+                                                                     if (size > 1) {
+                                                                         rust::Vec<float> store;
+                                                                         store.reserve(size);
+                                                                         for (int i = 0;
+                                                                              i < size; i++) {
+                                                                             store[i] = (float) array.getValueAtIndex(
+                                                                                     runtime,
+                                                                                     i).asNumber();
+                                                                         }
+
+                                                                         rust::Slice<const float> buf(
+                                                                                 store.data(),
+                                                                                 store.size());
+                                                                         canvas_native_path_round_rect(
+                                                                                 this->GetPath(),
+                                                                                 x, y,
+                                                                                 width,
+                                                                                 height, buf);
+
+                                                                     }
+                                                                 }
+                                                             } else {
+                                                                 auto radii = (float) arguments[4].asNumber();
+                                                                 canvas_native_path_round_rect_tl_tr_br_bl(
+                                                                         this->GetPath(), x, y,
+                                                                         width,
+                                                                         height, radii, radii,
+                                                                         radii, radii);
+
+                                                             }
+                                                         }
+
+                                                         return jsi::Value::undefined();
+
+                                                     }
+        );
+    } else if (methodName == "__toSVG") {
+        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 {
+
+
+                                                         auto d = canvas_native_path_to_string(
+                                                                 this->GetPath());
+                                                         return jsi::String::createFromAscii(
+                                                                 runtime, d.data(), d.size());
+                                                     }
+        );
+
+    }
+
+    return jsi::Value::undefined();
+}
+
+Path &Path2D::GetPath() {
+    return *this->path_;
+}
+

package/platforms/ios/src/cpp/canvas2d/TextMetricsImpl.h

@@ -0,0 +1,29 @@
+//
+// Created by Osei Fortune on 18/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import "NativeScript/JSIRuntime.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT TextMetricsImpl : public jsi::HostObject {
+public:
+    TextMetricsImpl(rust::Box<TextMetrics> metrics);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    TextMetrics &GetTextMetrics();
+
+
+private:
+    rust::Box<TextMetrics> metrics_;
+};
+