@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkColorFilter.h

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

package/cpp/api/JsiSkColorFilterFactory.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+#include <jsi/jsi.h>
+#include <utility>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkColorFilter.h>
+#include <SkLumaColorFilter.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkColorFilterFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeMatrix) {
+    auto jsiMatrix = arguments[0].asObject(runtime).asArray(runtime);
+    float matrix[20];
+    for (int i = 0; i < 20; i++) {
+      if (jsiMatrix.size(runtime) > i) {
+        matrix[i] = jsiMatrix.getValueAtIndex(runtime, i).asNumber();
+      }
+    }
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Matrix(std::move(matrix))));
+  }
+
+  JSI_HOST_FUNCTION(MakeBlend) {
+    auto color = arguments[0].asNumber();
+    SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Blend(color, blend)));
+  }
+
+  JSI_HOST_FUNCTION(MakeCompose) {
+    auto outer = JsiSkColorFilter::fromValue(runtime, arguments[0]);
+    auto inner = JsiSkColorFilter::fromValue(runtime, arguments[1]);
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Compose(std::move(outer), std::move(inner))));
+  }
+
+  JSI_HOST_FUNCTION(MakeLerp) {
+    auto t = arguments[0].asNumber();
+    auto dst = JsiSkColorFilter::fromValue(runtime, arguments[1]);
+    auto src = JsiSkColorFilter::fromValue(runtime, arguments[2]);
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::Lerp(t, std::move(dst), std::move(src))));
+  }
+
+    JSI_HOST_FUNCTION(MakeSRGBToLinearGamma) {
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+              runtime, std::make_shared<JsiSkColorFilter>(
+                      getContext(), SkColorFilters::SRGBToLinearGamma()));
+    }
+
+  JSI_HOST_FUNCTION(MakeLinearToSRGBGamma) {
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkColorFilters::LinearToSRGBGamma()));
+  }
+
+  JSI_HOST_FUNCTION(MakeLumaColorFilter) {
+    // Return the newly constructed object
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkColorFilter>(
+                     getContext(), SkLumaColorFilter::Make()));
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeMatrix),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeBlend),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeCompose),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLerp),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeSRGBToLinearGamma),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLinearToSRGBGamma),
+    JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeLumaColorFilter)
+  )
+
+  JsiSkColorFilterFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+} // namespace RNSkia

package/cpp/api/JsiSkContourMeasure.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkContourMeasure.h>
+
+#pragma clang diagnostic pop
+
+
+namespace RNSkia
+{
+
+    using namespace facebook;
+
+    class JsiSkContourMeasure : public JsiSkWrappingSkPtrHostObject<SkContourMeasure>
+    {
+    public:
+        JsiSkContourMeasure(std::shared_ptr<RNSkPlatformContext> context,
+                            const sk_sp<SkContourMeasure> contourMeasure)
+            : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(contourMeasure))
+        {
+            if (contourMeasure == nullptr)
+            {
+                jsi::detail::throwJSError(*context->getJsRuntime(), "Contour measure is null");
+            }
+        };
+
+        JSI_HOST_FUNCTION(getPosTan)
+        {
+            auto dist = arguments[0].asNumber();
+            SkPoint position;
+            SkPoint tangent;
+            auto result = getObject()->getPosTan(dist, &position, &tangent);
+            if (!result)
+            {
+                jsi::detail::throwJSError(runtime, "getSegment() failed");
+            }
+            auto posTan = jsi::Object(runtime);
+            posTan.setProperty(runtime, "px", position.x());
+            posTan.setProperty(runtime, "py", position.y());
+            posTan.setProperty(runtime, "tx", tangent.x());
+            posTan.setProperty(runtime, "ty", tangent.y());
+            return posTan;
+        }
+
+        JSI_HOST_FUNCTION(length)
+        {
+            return jsi::Value(SkScalarToDouble(getObject()->length()));
+        }
+
+        JSI_HOST_FUNCTION(isClosed)
+        {
+            return jsi::Value(getObject()->isClosed());
+        }
+
+        JSI_HOST_FUNCTION(getSegment)
+        {
+            auto start = arguments[0].asNumber();
+            auto end = arguments[1].asNumber();
+            auto startWithMoveTo = arguments[2].getBool();
+            SkPath path;
+            auto result = getObject()->getSegment(start, end, &path, startWithMoveTo);
+            if (!result)
+            {
+                jsi::detail::throwJSError(runtime, "getSegment() failed");
+            }
+            return JsiSkPath::toValue(runtime, getContext(), std::move(path));
+        }
+
+        JSI_PROPERTY_GET(__typename__)
+        {
+            return jsi::String::createFromUtf8(runtime, "ContourMeasure");
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkContourMeasure, __typename__))
+
+        JSI_EXPORT_FUNCTIONS(
+            JSI_EXPORT_FUNC(JsiSkContourMeasure, getPosTan),
+            JSI_EXPORT_FUNC(JsiSkContourMeasure, length),
+            JSI_EXPORT_FUNC(JsiSkContourMeasure, isClosed),
+            JSI_EXPORT_FUNC(JsiSkContourMeasure, getSegment))
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static sk_sp<SkContourMeasure> fromValue(jsi::Runtime &runtime,
+                                                 const jsi::Value &obj)
+        {
+            return obj.asObject(runtime)
+                .asHostObject<JsiSkContourMeasure>(runtime)
+                ->getObject();
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkContourMeasureIter.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkContourMeasure.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkContourMeasure.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia
+{
+
+        using namespace facebook;
+
+        class JsiSkContourMeasureIter : public JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter>
+        {
+        public:
+                JsiSkContourMeasureIter(
+                    std::shared_ptr<RNSkPlatformContext> context,
+                    const SkPath &path,
+                    bool forceClosed,
+                    SkScalar resScale = 1) : JsiSkWrappingSharedPtrHostObject<SkContourMeasureIter>(std::move(context), std::make_shared<SkContourMeasureIter>(path, forceClosed, resScale)) {}
+
+                // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+                JSI_PROPERTY_GET(__typename__)
+                {
+                        return jsi::String::createFromUtf8(runtime, "ContourMeasureIter");
+                }
+
+                JSI_EXPORT_PROPERTY_GETTERS(
+                    JSI_EXPORT_PROP_GET(JsiSkContourMeasureIter, __typename__), )
+
+                JSI_HOST_FUNCTION(next)
+                {
+                        auto next = getObject()->next();
+                        if (next == nullptr)
+                        {
+                                return jsi::Value::undefined();
+                        }
+                        auto nextObject = std::make_shared<JsiSkContourMeasure>(getContext(), std::move(next));
+
+                        return jsi::Object::createFromHostObject(runtime, std::move(nextObject));
+                }
+
+                JSI_EXPORT_FUNCTIONS(
+                    JSI_EXPORT_FUNC(JsiSkContourMeasureIter, next))
+
+                /**
+                Returns the underlying object from a host object of this type
+               */
+                static std::shared_ptr<SkContourMeasureIter> fromValue(jsi::Runtime &runtime,
+                                                                       const jsi::Value &obj)
+                {
+                        return obj.asObject(runtime)
+                            .asHostObject<JsiSkContourMeasureIter>(runtime)
+                            ->getObject();
+                }
+
+                /**
+                 * Creates the function for construction a new instance of the SkContourMeasureIter
+                 * wrapper
+                 * @param context platform context
+                 * @return A function for creating a new host object wrapper for the SkContourMeasureIter
+                 * class
+                 */
+                static const jsi::HostFunctionType
+                createCtor(std::shared_ptr<RNSkPlatformContext> context)
+                {
+                        return JSI_HOST_FUNCTION_LAMBDA
+                        {
+                                auto path = JsiSkPath::fromValue(runtime, arguments[0]);
+                                auto forceClosed = arguments[1].getBool();
+                                auto resScale = arguments[2].asNumber();
+                                // Return the newly constructed object
+                                return jsi::Object::createFromHostObject(
+                                    runtime, std::make_shared<JsiSkContourMeasureIter>(
+                                                 std::move(context),
+                                                 *path,
+                                                 forceClosed,
+                                                 resScale));
+                        };
+                }
+        };
+} // namespace RNSkia

package/cpp/api/JsiSkData.h

@@ -0,0 +1,46 @@
+#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 <SkStream.h>
+
+#pragma clang diagnostic pop
+
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkData : public JsiSkWrappingSkPtrHostObject<SkData> {
+    public:
+        JsiSkData(std::shared_ptr<RNSkPlatformContext> context,
+                      sk_sp<SkData> asset)
+                : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(asset)){}
+
+
+        JSI_PROPERTY_GET(__typename__) {
+            return jsi::String::createFromUtf8(runtime, "Data");
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkData, __typename__))
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static sk_sp<SkData> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+            return obj.asObject(runtime)
+                    .asHostObject<JsiSkData>(runtime)
+                    ->getObject();
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkDataFactory.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+#include <ReactCommon/TurboModuleUtils.h>
+
+#include "JsiSkData.h"
+
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkDataFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(fromURI) {
+            auto jsiLocalUri = arguments[0].asString(runtime);
+            auto localUri = jsiLocalUri.utf8(runtime);
+            auto context = getContext();
+            return react::createPromiseAsJSIValue(
+                    runtime,
+                    [context = std::move(context), localUri = std::move(localUri)](jsi::Runtime &runtime,
+                                        std::shared_ptr<react::Promise> promise) -> void {
+                        // Create a stream operation - this will be run in a
+                        // separate thread
+                        context->performStreamOperation(
+                                localUri,
+                                [&runtime, context = std::move(context), promise = std::move(promise)](
+                                        std::unique_ptr<SkStreamAsset> stream) -> void {
+                                    // Schedule drawCallback on the Javascript thread
+                                    auto result = SkData::MakeFromStream(stream.get(), stream->getLength());
+                                    context->runOnJavascriptThread([&runtime, context = std::move(context), promise = std::move(promise),
+                                                                           result = std::move(result)]() {
+                                        promise->resolve(jsi::Object::createFromHostObject(
+                                                runtime,
+                                                std::make_shared<JsiSkData>(std::move(context),
+                                                                            std::move(result))));
+                                    });
+                        });
+            });
+        };
+
+        JSI_HOST_FUNCTION(fromBytes) {
+            auto array = arguments[0].asObject(runtime);
+            jsi::ArrayBuffer buffer = array
+                    .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+                    .asObject(runtime)
+                    .getArrayBuffer(runtime);
+
+            auto data = SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
+            return jsi::Object::createFromHostObject(runtime,
+                                                     std::make_shared<JsiSkData>(
+                                                             getContext(), std::move(data)));
+        }
+
+        JSI_HOST_FUNCTION(fromBase64) {
+            auto base64 = arguments[0].asString(runtime);
+            auto base64Str = base64.utf8(runtime);
+            auto size = base64Str.size();
+
+            // Calculate length
+            size_t len;
+            auto err = SkBase64::Decode(&base64.utf8(runtime).c_str()[0], size, nullptr, &len);
+            if(err != SkBase64::Error::kNoError) {
+              jsi::detail::throwJSError(runtime, "Error decoding base64 string");
+              return jsi::Value::undefined();
+            }
+
+            // Create data object and decode
+            auto data = SkData::MakeUninitialized(len);
+            err = SkBase64::Decode(&base64.utf8(runtime).c_str()[0], size, data->writable_data(), &len);
+            if(err != SkBase64::Error::kNoError) {
+              jsi::detail::throwJSError(runtime, "Error decoding base64 string");
+              return jsi::Value::undefined();
+            }
+          
+            return jsi::Object::createFromHostObject(runtime,
+                                                     std::make_shared<JsiSkData>(
+                                                             getContext(), std::move(data)));
+        }
+
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkDataFactory, fromURI),
+                             JSI_EXPORT_FUNC(JsiSkDataFactory, fromBytes),
+                             JSI_EXPORT_FUNC(JsiSkDataFactory, fromBase64))
+
+        JsiSkDataFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia