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

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

@@ -0,0 +1,16 @@
+//
+// Created by Osei Fortune on 17/03/2023.
+//
+
+#pragma once
+#include "NativeScript/JSIRuntime.h"
+
+using namespace facebook;
+
+struct JSIReadFileCallback {
+    std::shared_ptr<jsi::Value> value_;
+    std::shared_ptr<jsi::Value> data_;
+
+    JSIReadFileCallback(std::shared_ptr<jsi::Value> value) : value_(std::move(value)) {}
+};
+

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

@@ -0,0 +1,24 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#include <cstdint>
+
+class OnRafCallback {
+    // 0 2d
+    // 1 gl
+    // 2 gl2
+public:
+    OnRafCallback(intptr_t context, uint32_t version);
+
+    void OnFrame(int64_t ts) const;
+
+private:
+    intptr_t context_;
+    uint32_t version_;
+};
+
+void OnRafCallbackOnFrame(intptr_t callback, int64_t ts);

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

@@ -0,0 +1,25 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#include "OnRafCallback.h"
+#include "canvas2d/CanvasRenderingContext2DImpl.h"
+#include "webgl/WebGLRenderingContextBase.h"
+
+OnRafCallback::OnRafCallback(intptr_t context, uint32_t version) : context_(context),
+                                                                   version_(version) {}
+
+void OnRafCallback::OnFrame(int64_t ts) const {
+    if (this->version_ == 0) {
+        CanvasRenderingContext2DImpl::Flush(this->context_);
+    }
+
+    if (this->version_ == 1 || this->version_ == 2) {
+        WebGLRenderingContextBase::Flush(this->context_);
+    }
+}
+
+void OnRafCallbackOnFrame(intptr_t callback, int64_t ts) {
+    auto ptr = reinterpret_cast<OnRafCallback *>(reinterpret_cast<intptr_t *>(callback));
+    ptr->OnFrame(ts);
+}

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

@@ -0,0 +1,27 @@
+//
+// Created by Osei Fortune on 20/04/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#include <cstdint>
+#include "OnRafCallback.h"
+
+using namespace org::nativescript::canvas;
+
+class RafImpl {
+public:
+    RafImpl(OnRafCallback *rafCallback, intptr_t callback, rust::Box<Raf> raf);
+
+    Raf &GetRaf() {
+        return *this->raf_;
+    }
+
+private:
+    OnRafCallback *rafCallback_;
+    intptr_t callback_;
+    rust::Box<Raf> raf_;
+};

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

@@ -0,0 +1,10 @@
+//
+// Created by Osei Fortune on 20/04/2022.
+//
+
+#include "RafImpl.h"
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+
+RafImpl::RafImpl(OnRafCallback *rafCallback, intptr_t callback, rust::Box<Raf> raf) : rafCallback_(
+        rafCallback), callback_(callback), raf_(std::move(raf)) {}

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

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

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

@@ -0,0 +1,97 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#include "TextDecoderImpl.h"
+
+TextDecoderImpl::TextDecoderImpl(rust::Box<TextDecoder> decoder) : decoder_(std::move(decoder)) {}
+
+std::vector<jsi::PropNameID> TextDecoderImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(2);
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("encoding")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("decode")));
+    return ret;
+}
+
+jsi::Value TextDecoderImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "encoding") {
+        auto encoding = canvas_native_text_decoder_get_encoding(this->GetTextDecoder());
+        return jsi::String::createFromAscii(runtime, encoding.data(), encoding.size());
+    } else if (methodName == "decode") {
+        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 {
+
+                                                         if (count == 1) {
+                                                             if (arguments[0].isNull() ||
+                                                                 arguments[0].isUndefined() ||
+                                                                 !arguments[0].isObject()) {
+
+                                                                 throw jsi::JSINativeException(
+                                                                         "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+                                                             }
+
+                                                             auto buf = arguments[0].asObject(
+                                                                     runtime);
+
+                                                             if (buf.isArrayBuffer(runtime)) {
+
+                                                                 auto buffer = buf.getArrayBuffer(
+                                                                         runtime);
+
+                                                                 auto data = buffer.data(runtime);
+                                                                 auto size = buffer.size(runtime);
+                                                                 rust::Slice<const uint8_t> slice{
+                                                                         data,
+                                                                         size};
+                                                                 auto decoded = canvas_native_text_decoder_decode(
+                                                                         this->GetTextDecoder(),
+                                                                         slice);
+                                                                 return jsi::String::createFromAscii(
+                                                                         runtime, decoded.data(),
+                                                                         decoded.size());
+                                                             }
+
+
+                                                             if (buf.isTypedArray(runtime)) {
+
+                                                                 auto buffer = buf.getTypedArray(
+                                                                         runtime);
+
+                                                                 auto data = GetTypedArrayData<const uint8_t>(
+                                                                         runtime, buffer);
+
+                                                                 auto decoded = canvas_native_text_decoder_decode(
+                                                                         this->GetTextDecoder(),
+                                                                         data);
+
+                                                                 return jsi::String::createFromAscii(
+                                                                         runtime, decoded.data(),
+                                                                         decoded.size());
+                                                             }
+
+
+                                                             throw jsi::JSINativeException(
+                                                                     "Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+
+
+                                                         }
+
+                                                         return jsi::String::createFromUtf8(runtime,
+                                                                                            "");
+                                                     }
+        );
+    }
+
+    return jsi::Value::undefined();
+}
+
+TextDecoder &TextDecoderImpl::GetTextDecoder() {
+    return *this->decoder_;
+}

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

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#include "VecMutableBuffer.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT TextEncoderImpl : public jsi::HostObject {
+
+public:
+    TextEncoderImpl(rust::Box<TextEncoder> encoder);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    TextEncoder &GetTextEncoder();
+
+private:
+    rust::Box<TextEncoder> encoder_;
+};

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

@@ -0,0 +1,60 @@
+//
+// Created by Osei Fortune on 19/04/2022.
+//
+
+#include "TextEncoderImpl.h"
+
+TextEncoderImpl::TextEncoderImpl(rust::Box<TextEncoder> encoder) : encoder_(std::move(encoder)) {}
+
+std::vector<jsi::PropNameID> TextEncoderImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(2);
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("encoding")));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("encode")));
+    return ret;
+}
+
+jsi::Value TextEncoderImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "encoding") {
+        auto encoding = canvas_native_text_encoder_get_encoding(this->GetTextEncoder());
+        return jsi::String::createFromAscii(runtime, encoding.data(), encoding.size());
+    } else if (methodName == "encode") {
+        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 text = arguments[0].asString(
+                                                                 runtime).utf8(runtime);
+
+                                                         auto data = canvas_native_text_encoder_encode(
+                                                                 this->GetTextEncoder(),
+                                                                 rust::Str(text.c_str()));
+
+                                                         auto buf = std::make_shared<VecMutableBuffer<uint8_t>>(
+                                                                 std::move(data));
+                                                         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();
+}
+
+TextEncoder &TextEncoderImpl::GetTextEncoder() {
+    return *this->encoder_;
+}

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

@@ -0,0 +1,51 @@
+//
+// Created by Osei Fortune on 28/02/2023.
+//
+
+#pragma once
+#ifndef CANVAS_ANDROID_VECMUTABLEBUFFER_H
+#define CANVAS_ANDROID_VECMUTABLEBUFFER_H
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#include "NativeScript/JSIRuntime.h"
+
+using namespace facebook;
+
+template<typename T>
+struct VecMutableBuffer : jsi::MutableBuffer {
+public:
+    VecMutableBuffer(rust::Vec<T> buffer) : vec_(std::move(buffer)) {
+        this->buf_ = vec_.data();
+        this->buffer_size_ = vec_.size();
+        this->size_ = vec_.size() * sizeof(T);
+    }
+
+    T *buffer_data() {
+        return this->buf_;
+    }
+
+    size_t buffer_size() const {
+        return this->buffer_size_;
+    }
+
+    uint8_t *data() override {
+        return (uint8_t *) this->buf_;
+    }
+
+    size_t size() const override {
+        return this->size_;
+    }
+
+    ~VecMutableBuffer() override {
+        this->buf_ = nullptr;
+    }
+
+private:
+    T *buf_;
+    size_t size_;
+    size_t buffer_size_;
+    rust::Vec<T> vec_;
+};
+
+#endif //CANVAS_ANDROID_VECMUTABLEBUFFER_H