@pompadour/react-native-skia 1.4.0

package/cpp/api/JsiSkColorFilter.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "JsiSkHostObjects.h"
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkColorFilter.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkColorFilter : public JsiSkWrappingSkPtrHostObject<SkColorFilter> {
+public:
+  JsiSkColorFilter(std::shared_ptr<RNSkPlatformContext> context,
+                   sk_sp<SkColorFilter> colorFilter)
+      : JsiSkWrappingSkPtrHostObject<SkColorFilter>(std::move(context),
+                                                    std::move(colorFilter)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkColorFilter, ColorFilter)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkColorFilter, dispose))
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkColorFilterFactory.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "JsiSkColor.h"
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkColorFilter.h"
+#include "include/effects/SkLumaColorFilter.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+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 = JsiSkColor::fromValue(runtime, arguments[0]);
+    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))
+
+  explicit JsiSkColorFilterFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+} // namespace RNSkia

package/cpp/api/JsiSkContourMeasure.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkContourMeasure.h"
+
+#include "JsiSkPath.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+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) {
+      throw jsi::JSError(*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) {
+      throw jsi::JSError(runtime, "getSegment() failed");
+    }
+    auto posTan = jsi::Array(runtime, 2);
+    auto pos = jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPoint>(getContext(), position));
+    auto tan = jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPoint>(getContext(), tangent));
+    posTan.setValueAtIndex(runtime, 0, pos);
+    posTan.setValueAtIndex(runtime, 1, tan);
+    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) {
+      throw jsi::JSError(runtime, "getSegment() failed");
+    }
+    return JsiSkPath::toValue(runtime, getContext(), std::move(path));
+  }
+
+  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasure, ContourMeasure)
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasure, getPosTan),
+                       JSI_EXPORT_FUNC(JsiSkContourMeasure, length),
+                       JSI_EXPORT_FUNC(JsiSkContourMeasure, isClosed),
+                       JSI_EXPORT_FUNC(JsiSkContourMeasure, getSegment),
+                       JSI_EXPORT_FUNC(JsiSkContourMeasure, dispose))
+};
+} // namespace RNSkia

package/cpp/api/JsiSkContourMeasureIter.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "JsiSkContourMeasure.h"
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkContourMeasure.h"
+
+#include "JsiSkPath.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+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)) {}
+
+  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));
+  }
+
+  EXPORT_JSI_API_TYPENAME(JsiSkContourMeasureIter, ContourMeasureIter)
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasureIter, next),
+                       JSI_EXPORT_FUNC(JsiSkContourMeasureIter, dispose))
+
+  /**
+   * 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,30 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkFont.h"
+#include "include/core/SkStream.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkData : public JsiSkWrappingSkPtrHostObject<SkData> {
+public:
+  JsiSkData(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkData> asset)
+      : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(asset)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkData, Data)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkData, dispose))
+};
+} // namespace RNSkia

package/cpp/api/JsiSkDataFactory.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiPromises.h"
+#include "JsiSkData.h"
+#include "third_party/base64.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkDataFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(fromURI) {
+    auto jsiLocalUri = arguments[0].asString(runtime);
+    auto localUri = jsiLocalUri.utf8(runtime);
+    auto context = getContext();
+    return RNJsi::JsiPromises::createPromiseAsJSIValue(
+        runtime,
+        [context = std::move(context), localUri = std::move(localUri)](
+            jsi::Runtime &runtime,
+            std::shared_ptr<RNJsi::JsiPromises::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 =
+        Base64::Decode(&base64.utf8(runtime).c_str()[0], size, nullptr, &len);
+    if (err != Base64::Error::kNone) {
+      throw jsi::JSError(runtime, "Error decoding base64 string");
+      return jsi::Value::undefined();
+    }
+
+    // Create data object and decode
+    auto data = SkData::MakeUninitialized(len);
+    err = Base64::Decode(&base64.utf8(runtime).c_str()[0], size,
+                         data->writable_data(), &len);
+    if (err != Base64::Error::kNone) {
+      throw jsi::JSError(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))
+
+  explicit JsiSkDataFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia