@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkSurfaceFactory.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#include <JsiSkSurface.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkSurface.h>
+#include <SkImage.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkSurfaceFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(Make) {
+            auto width = static_cast<int>(arguments[0].asNumber());
+            auto height = static_cast<int>(arguments[1].asNumber());
+            auto surface = SkSurface::MakeRasterN32Premul(width, height);
+            if(surface == nullptr) {
+                return jsi::Value::null();
+            }
+            return jsi::Object::createFromHostObject(runtime,
+                std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+        }
+      
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make))
+
+        JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)
+            : JsiSkHostObject(std::move(context)) {}
+
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkTextBlob.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkTextBlob.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkTextBlob : public JsiSkWrappingSkPtrHostObject<SkTextBlob> {
+    public:
+        JsiSkTextBlob(
+                std::shared_ptr<RNSkPlatformContext> context,
+                sk_sp<SkTextBlob> shader
+        ) : JsiSkWrappingSkPtrHostObject<SkTextBlob>(std::move(context), std::move(shader)) {}
+
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+
+        JSI_PROPERTY_GET(__typename__) {
+            return jsi::String::createFromUtf8(runtime, "TextBlob");
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(
+                JSI_EXPORT_PROP_GET(JsiSkTextBlob, __typename__),
+        )
+
+        /**
+        Returns the underlying object from a host object of this type
+       */
+        static sk_sp<SkTextBlob> fromValue(jsi::Runtime &runtime,
+                                                    const jsi::Value &obj) {
+            return obj.asObject(runtime)
+                        .asHostObject<JsiSkTextBlob>(runtime)
+                        ->getObject();
+
+        }
+
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkTextBlobFactory.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkTextBlob.h"
+#include "JsiSkRSXform.h"
+#include "JsiSkFont.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkTextBlob.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkTextBlobFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(MakeFromText) {
+            auto str = arguments[0].asString(runtime).utf8(runtime);
+            auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+            auto textBlob = SkTextBlob::MakeFromString(str.c_str(), *font);
+            return jsi::Object::createFromHostObject(
+                    runtime,
+                    std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob))
+            );
+        }
+
+        JSI_HOST_FUNCTION(MakeFromGlyphs) {
+            auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+            auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+            int bytesPerGlyph = 2;
+            std::vector<SkGlyphID> glyphs;
+            int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+            glyphs.reserve(glyphsSize);
+            for (int i = 0; i < glyphsSize; i++) {
+                glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+            }
+            auto textBlob =  SkTextBlob::MakeFromText(glyphs.data(), glyphs.size() * bytesPerGlyph, *font, SkTextEncoding::kGlyphID);
+            return jsi::Object::createFromHostObject(
+                    runtime,
+                    std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob))
+            );
+        }
+
+        JSI_HOST_FUNCTION(MakeFromRSXform) {
+            auto str = arguments[0].asString(runtime).utf8(runtime);
+            auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
+            auto font = JsiSkFont::fromValue(runtime, arguments[2]);            
+            std::vector<SkRSXform> rsxforms;
+            int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
+            rsxforms.reserve(rsxformsSize);
+            for (int i = 0; i < rsxformsSize; i++) {
+                auto rsxform = JsiSkRSXform::fromValue(runtime, jsiRsxforms.getValueAtIndex(runtime, i));
+                rsxforms.push_back(*rsxform);
+            }
+            auto textBlob = SkTextBlob::MakeFromRSXform(str.c_str(), str.length(), rsxforms.data(), *font);
+            return jsi::Object::createFromHostObject(
+                    runtime,
+                    std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob))
+            );
+        }
+
+        JSI_HOST_FUNCTION(MakeFromRSXformGlyphs) {
+            auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+            auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
+            auto font = JsiSkFont::fromValue(runtime, arguments[2]);
+            int bytesPerGlyph = 2;
+            std::vector<SkGlyphID> glyphs;
+            int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+            glyphs.reserve(glyphsSize);
+            for (int i = 0; i < glyphsSize; i++) {
+                glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+            }
+            std::vector<SkRSXform> rsxforms;
+            int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
+            rsxforms.reserve(rsxformsSize);
+            for (int i = 0; i < rsxformsSize; i++) {
+                auto rsxform = JsiSkRSXform::fromValue(runtime, jsiRsxforms.getValueAtIndex(runtime, i));
+                rsxforms.push_back(*rsxform);
+            }
+            auto textBlob = SkTextBlob::MakeFromRSXform(glyphs.data(), glyphs.size() * bytesPerGlyph, rsxforms.data(), *font, SkTextEncoding::kGlyphID);
+            return jsi::Object::createFromHostObject(
+                    runtime,
+                    std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob))
+            );
+        }
+
+
+        JSI_EXPORT_FUNCTIONS(
+            JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromText),
+            JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromGlyphs),
+            JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromRSXform),
+            JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromRSXformGlyphs),
+        )
+
+        JsiSkTextBlobFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypeface.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkFont.h>
+#include <SkTypeface.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkTypeface : public JsiSkWrappingSkPtrHostObject<SkTypeface> {
+public:
+  JSI_PROPERTY_GET(bold) { return jsi::Value(getObject()->isBold()); }
+  JSI_PROPERTY_GET(italic) { return jsi::Value(getObject()->isItalic()); }
+  // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+  JSI_PROPERTY_GET(__typename__) {
+    return jsi::String::createFromUtf8(runtime, "Typeface");
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkTypeface, bold),
+                              JSI_EXPORT_PROP_GET(JsiSkTypeface, italic),
+                              JSI_EXPORT_PROP_GET(JsiSkTypeface, __typename__))
+
+  JsiSkTypeface(std::shared_ptr<RNSkPlatformContext> context,
+                sk_sp<SkTypeface> typeface)
+      : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(typeface)){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkTypeface> fromValue(jsi::Runtime &runtime,
+                                     const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkTypeface>(runtime)
+        ->getObject();
+  }
+
+  /**
+   Returns the jsi object from a host object of this type
+  */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                              std::shared_ptr<RNSkPlatformContext> context,
+                              sk_sp<SkTypeface> tf) {
+    return jsi::Object::createFromHostObject(
+              runtime, std::make_shared<JsiSkTypeface>(std::move(context), std::move(tf)));
+  }
+
+private:
+  static SkFontStyle getFontStyleFromNumber(int fontStyle) {
+    switch (fontStyle) {
+    case 0:
+      return SkFontStyle::Normal();
+    case 1:
+      return SkFontStyle::Bold();
+    case 2:
+      return SkFontStyle::Italic();
+    case 3:
+      return SkFontStyle::BoldItalic();
+    default:
+      return SkFontStyle::Normal();
+    };
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypefaceFactory.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkTypeface.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkData.h"
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkTypefaceFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
+            auto data = JsiSkData::fromValue(runtime, arguments[0]);
+            return jsi::Object::createFromHostObject(
+                runtime, std::make_shared<JsiSkTypeface>(getContext(), SkFontMgr::RefDefault()->makeFromData(std::move(data))));
+        }
+
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFactory, MakeFreeTypeFaceFromData))
+
+        JsiSkTypefaceFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkVertices.h

@@ -0,0 +1,147 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <jsi/jsi.h>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkVertices.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkVertices : public JsiSkWrappingSkPtrHostObject<SkVertices> {
+    public:
+
+        JsiSkVertices(std::shared_ptr<RNSkPlatformContext> context,
+        sk_sp<SkVertices> vertices)
+        : JsiSkWrappingSkPtrHostObject<SkVertices>(std::move(context), std::move(vertices)) {}
+
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+        JSI_PROPERTY_GET(__typename__) {
+            return jsi::String::createFromUtf8(runtime, "Vertices");
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkVertices, __typename__))
+
+        JSI_HOST_FUNCTION(bounds) {
+            const auto& result = getObject()->bounds();
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRect>(getContext(), result));
+        }
+
+        JSI_HOST_FUNCTION(uniqueID) {
+            return static_cast<double>(getObject()->uniqueID());
+        }
+
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkVertices, bounds),
+                             JSI_EXPORT_FUNC(JsiSkVertices, uniqueID), )
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static sk_sp<SkVertices> fromValue(jsi::Runtime &runtime,
+                                                 const jsi::Value &obj) {
+            return obj.asObject(runtime)
+                        .asHostObject<JsiSkVertices>(runtime)
+                        ->getObject();
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkVertices
+         * wrapper
+         * @param context platform context
+         * @return A function for creating a new host object wrapper for the SkVertices
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+            return JSI_HOST_FUNCTION_LAMBDA {
+                auto mode = static_cast<SkVertices::VertexMode>(arguments[0].getNumber());
+                std::vector<SkPoint> positions;
+                std::vector<SkPoint> texs;
+                std::vector<SkColor> colors;
+                std::vector<uint16_t> indices;
+
+                auto jsiPositions = arguments[1].asObject(runtime).asArray(runtime);
+                auto positionsSize = static_cast<int>(jsiPositions.size(runtime));
+                positions.reserve(positionsSize);
+                for (int i = 0; i < positionsSize; i++) {
+                    std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
+                            runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
+                    positions.push_back(*point.get());
+                }
+
+                if (count >= 3 && !arguments[2].isNull() && !arguments[2].isUndefined()) {
+                    auto jsiTexs = arguments[2].asObject(runtime).asArray(runtime);
+                    auto texsSize = jsiTexs.size(runtime);
+                    texs.reserve(texsSize);
+                    for (int i = 0; i < texsSize; i++) {
+                        auto point = JsiSkPoint::fromValue(
+                                runtime, jsiTexs.getValueAtIndex(runtime, i).asObject(runtime));
+                        texs.push_back(*point.get());
+                    }
+                }
+
+                if (count >= 4 && !arguments[3].isNull() && !arguments[3].isUndefined()) {
+                    auto jsiColors = arguments[3].asObject(runtime).asArray(runtime);
+                    auto colorsSize = jsiColors.size(runtime);
+                    colors.reserve(colorsSize);
+                    for (int i = 0; i < colorsSize; i++) {
+                        SkColor color = jsiColors.getValueAtIndex(runtime, i).asNumber();
+                        colors.push_back(color);
+                    }
+                }
+
+                int indicesSize = 0;
+                if (count >= 5 && !arguments[4].isNull() && !arguments[4].isUndefined()) {
+                    auto jsiIndices = arguments[4].asObject(runtime).asArray(runtime);
+                    indicesSize = static_cast<int>(jsiIndices.size(runtime));
+                    indices.reserve(indicesSize);
+                    for (int i = 0; i < indicesSize; i++) {
+                        uint16_t index = jsiIndices.getValueAtIndex(runtime, i).asNumber();
+                        indices.push_back(index);
+                    }
+                }
+// TODO: this is the technic used in CanvasKit: https://github.com/google/skia/blob/main/modules/canvaskit/interface.js#L1216
+// Note that the isVolatile parameter is unused when using MakeCopy()
+//                auto isVolatile = count >= 6 && !arguments[5].isNull() && !arguments[5].isUndefined() ? arguments[5].getBool() : false;
+//                auto flags = 0;
+//                // These flags are from SkVertices.h and should be kept in sync with those.
+//                if (texs.size() > 0) {
+//                    flags |= (1 << 0);
+//                }
+//                if (colors.size() > 0) {
+//                    flags |= (1 << 1);
+//                }
+//                if (!isVolatile) {
+//                    flags |= (1 << 2);
+//                }
+//                auto builder = SkVertices::Builder(mode, positionsSize/2, indicesSize, flags);
+//                std::copy(positions.data(), positions.data() + positionsSize, builder.positions());
+//                if (builder.texCoords()) {
+//                    std::copy(std::begin(texs), std::end(texs), builder.texCoords());
+//                }
+//                if (builder.colors()) {
+//                    std::copy(std::begin(colors), std::end(colors), builder.colors());
+//                }
+//                if (builder.indices()) {
+//                    std::copy(std::begin(indices), std::end(indices), builder.indices());
+//                }
+//                auto vertices = builder.detach();
+                auto vertices = SkVertices::MakeCopy(mode, positionsSize, positions.data(), texs.data(), colors.data(), indicesSize, indices.data());
+                return jsi::Object::createFromHostObject(
+                        runtime, std::make_shared<JsiSkVertices>(context, std::move(vertices)));
+            };
+        }
+    };
+} // namespace RNSkia

package/cpp/jsi/JsiHostObject.cpp

@@ -0,0 +1,154 @@
+#include <JsiHostObject.h>
+#include <functional>
+#include <vector>
+
+// To be able to find objects that aren't cleaned up correctly,
+// we can set this value to 1 and debug the constructor/destructor
+#define JSI_DEBUG_ALLOCATIONS 0
+
+namespace RNJsi {
+
+#if JSI_DEBUG_ALLOCATIONS
+int objCounter = 0;
+std::vector<JsiHostObject *> objects;
+#endif
+
+JsiHostObject::JsiHostObject() {
+#if JSI_DEBUG_ALLOCATIONS
+  objects.push_back(this);
+  objCounter++;
+#endif
+}
+JsiHostObject::~JsiHostObject() {
+#if JSI_DEBUG_ALLOCATIONS
+  for (size_t i = 0; i < objects.size(); ++i) {
+    if (objects.at(i) == this) {
+      objects.erase(objects.begin() + i);
+      break;
+    }
+  }
+  objCounter--;
+#endif
+}
+
+void JsiHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                        const jsi::Value &value) {
+  
+  auto nameVal = name.utf8(rt);
+  auto nameStr = nameVal.c_str();
+
+  /** Check the static setters map */
+  const JsiPropertySettersMap &setters = getExportedPropertySettersMap();
+  auto setter = setters.find(nameStr);
+  if (setter != setters.end()) {
+    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1,
+                                std::placeholders::_2);
+    return dispatcher(rt, value);
+  }
+
+  if (_propMap.count(nameStr) > 0) {
+    auto prop = _propMap.at(nameStr);
+    (prop.set)(rt, value);
+  }
+}
+
+jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
+                              const jsi::PropNameID &name) {
+  auto nameVal = name.utf8(runtime);
+  auto nameStr = nameVal.c_str();
+  
+  // Check the static getters map
+  const JsiPropertyGettersMap &getters = getExportedPropertyGettersMap();
+  auto getter = getters.find(nameStr);
+  if (getter != getters.end()) {
+    auto dispatcher = std::bind(getter->second, this, std::placeholders::_1);
+    return dispatcher(runtime);
+  }
+
+  // Check the cache for functions
+  auto runtimeCache = _cache.find(&runtime);
+  JsiHostFunctionCache *currentCache;
+  if (runtimeCache != _cache.end()) {
+    currentCache = &runtimeCache->second;
+    // Check if the runtime cache as a cache of the host function
+    auto cachedFunc = runtimeCache->second.find(nameStr);
+    if (cachedFunc != runtimeCache->second.end()) {
+      return cachedFunc->second->asFunction(runtime);
+    }
+  } else {
+    // Create cache for this runtime
+    JsiHostFunctionCache runtimeCache;
+    _cache.emplace(&runtime, JsiHostFunctionCache{});
+    currentCache = &_cache.at(&runtime);
+  }
+
+  // Check the static function map
+  const JsiFunctionMap &funcs = getExportedFunctionMap();
+  auto func = funcs.find(nameStr);
+  if (func != funcs.end()) {
+    auto dispatcher = std::bind(func->second, (JsiHostObject *)this,
+                                std::placeholders::_1, std::placeholders::_2,
+                                std::placeholders::_3, std::placeholders::_4);
+
+    // Add to cache
+    currentCache->emplace(nameStr, std::make_unique<jsi::Function>(
+                                       jsi::Function::createFromHostFunction(
+                                           runtime, name, 0, dispatcher)));
+
+    // return retVal;
+    return currentCache->at(nameStr)->asFunction(runtime);
+  }
+
+  if (_funcMap.count(nameStr) > 0) {
+    return jsi::Function::createFromHostFunction(runtime, name, 0,
+                                                 _funcMap.at(nameStr));
+  }
+
+  if (_propMap.count(nameStr) > 0) {
+    auto prop = _propMap.at(nameStr);
+    return (prop.get)(runtime);
+  }
+
+  return jsi::Value::undefined();
+}
+
+std::vector<jsi::PropNameID>
+JsiHostObject::getPropertyNames(jsi::Runtime &runtime) {
+  // statically exported functions
+  const auto& funcs = getExportedFunctionMap();
+
+  // Statically exported property getters
+  const auto& getters = getExportedPropertyGettersMap();
+
+  // Statically exported property setters
+  const auto& setters = getExportedPropertySettersMap();
+
+  std::vector<jsi::PropNameID> propNames;
+  propNames.reserve(funcs.size() + getters.size() + setters.size() + _funcMap.size() + _propMap.size());
+
+  for (auto it = funcs.cbegin(); it != funcs.cend(); ++it) {
+    propNames.push_back(jsi::PropNameID::forAscii(runtime, it->first));
+  }
+
+  for (auto it = getters.cbegin(); it != getters.cend(); ++it) {
+    propNames.push_back(jsi::PropNameID::forUtf8(runtime, it->first));
+  }
+
+  for (auto it = getters.cbegin(); it != getters.cend(); ++it) {
+    if (getters.count(it->first) == 0) {
+      propNames.push_back(jsi::PropNameID::forUtf8(runtime, it->first));
+    }
+  }
+
+  // functions
+  for (auto it = _funcMap.cbegin(); it != _funcMap.cend(); ++it) {
+    propNames.push_back(jsi::PropNameID::forAscii(runtime, it->first));
+  }
+  // props
+  for (auto it = _propMap.cbegin(); it != _propMap.cend(); ++it) {
+    propNames.push_back(jsi::PropNameID::forAscii(runtime, it->first));
+  }
+  return propNames;
+}
+
+} // namespace RNJsi