@nativescript/canvas 2.0.0-alpha.20 → 2.0.0-alpha.21

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

@@ -1,68 +0,0 @@
-//
-// 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.mm

@@ -1,149 +0,0 @@
-//
-// 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.mm

@@ -1,335 +0,0 @@
-//
-// 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.mm

@@ -1,68 +0,0 @@
-//
-// Created by Osei Fortune on 18/04/2022.
-//
-
-#include "TextMetricsImpl.h"
-#include "canvas-cxx/src/lib.rs.h"
-
-TextMetricsImpl::TextMetricsImpl(rust::Box<TextMetrics> metrics) : metrics_(std::move(metrics)) {}
-
-std::vector<jsi::PropNameID> TextMetricsImpl::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("actualBoundingBoxLeft")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("actualBoundingBoxRight")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("actualBoundingBoxAscent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("actualBoundingBoxDescent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fontBoundingBoxAscent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("fontBoundingBoxDescent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("emHeightAscent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("emHeightDescent")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("hangingBaseline")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("alphabeticBaseline")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("ideographicBaseline")));
-    return ret;
-}
-
-jsi::Value TextMetricsImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
-    auto methodName = name.utf8(runtime);
-    if (methodName == "width") {
-        return {(double) canvas_native_text_metrics_get_width(this->GetTextMetrics())};
-    } else if (methodName == "actualBoundingBoxLeft") {
-        return {(double) canvas_native_text_metrics_get_actual_bounding_box_left(
-                this->GetTextMetrics())};
-    } else if (methodName == "actualBoundingBoxRight") {
-        return {(double) canvas_native_text_metrics_get_actual_bounding_box_right(
-                this->GetTextMetrics())};
-    } else if (methodName == "actualBoundingBoxAscent") {
-        return {(double) canvas_native_text_metrics_get_actual_bounding_box_ascent(
-                this->GetTextMetrics())};
-    } else if (methodName == "actualBoundingBoxDescent") {
-        return {(double) canvas_native_text_metrics_get_actual_bounding_box_descent(
-                this->GetTextMetrics())};
-    } else if (methodName == "fontBoundingBoxAscent") {
-        return {(double) canvas_native_text_metrics_get_font_bounding_box_ascent(
-                this->GetTextMetrics())};
-    } else if (methodName == "fontBoundingBoxDescent") {
-        return {(double) canvas_native_text_metrics_get_font_bounding_box_descent(
-                this->GetTextMetrics())};
-    } else if (methodName == "emHeightAscent") {
-        return {(double) canvas_native_text_metrics_get_em_height_ascent(this->GetTextMetrics())};
-    } else if (methodName == "emHeightDescent") {
-        return {(double) canvas_native_text_metrics_get_em_height_descent(this->GetTextMetrics())};
-    } else if (methodName == "alphabeticBaseline") {
-        return {(double) canvas_native_text_metrics_get_alphabetic_baseline(
-                this->GetTextMetrics())};
-    } else if (methodName == "ideographicBaseline") {
-        return {(double) canvas_native_text_metrics_get_ideographic_baseline(
-                this->GetTextMetrics())};
-    }
-
-    return jsi::Value::undefined();
-}
-
-
-TextMetrics &TextMetricsImpl::GetTextMetrics() {
-    return *this->metrics_;
-}