@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkPathEffectFactory.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPathEffect.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkCornerPathEffect.h>
+#include <SkDashPathEffect.h>
+#include <SkDiscretePathEffect.h>
+#include <SkPathEffect.h>
+#include "include/effects/Sk1DPathEffect.h"
+#include "include/effects/Sk2DPathEffect.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPathEffectFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeCorner) {
+    int radius = arguments[0].asNumber();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(), SkCornerPathEffect::Make(radius)));
+  }
+
+  JSI_HOST_FUNCTION(MakeDash) {
+    auto jsiIntervals = arguments[0].asObject(runtime).asArray(runtime);
+    auto size = (int)jsiIntervals.size(runtime);
+    std::vector<SkScalar> intervals;
+    intervals.reserve(size);
+    for (int i = 0; i < size; i++) {
+      SkScalar interval = jsiIntervals.getValueAtIndex(runtime, i).asNumber();
+      intervals.push_back(interval);
+    }
+    int phase = count >= 2 && !arguments[1].isUndefined() && !arguments[1].isNull() ? arguments[1].asNumber() : 0;
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(),
+                     SkDashPathEffect::Make(intervals.data(), size, phase)));
+  }
+
+  JSI_HOST_FUNCTION(MakeDiscrete) {
+    int segLength = arguments[0].asNumber();
+    int dec = arguments[1].asNumber();
+    int seedAssist = arguments[2].asNumber();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPathEffect>(
+                     getContext(),
+                     SkDiscretePathEffect::Make(segLength, dec, seedAssist)));
+  }
+
+  JSI_HOST_FUNCTION(MakeCompose) {
+    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
+    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPathEffect::MakeCompose(std::move(outer), std::move(inner))));
+  }
+
+  JSI_HOST_FUNCTION(MakeSum) {
+    auto outer = JsiSkPathEffect::fromValue(runtime, arguments[0]);
+    auto inner = JsiSkPathEffect::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPathEffect::MakeSum(std::move(outer), std::move(inner))));
+  }
+
+  JSI_HOST_FUNCTION(MakePath1D) {
+    auto path = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto advance = arguments[1].asNumber();
+    auto phase = arguments[2].asNumber();
+    auto style = static_cast<SkPath1DPathEffect::Style>(arguments[3].asNumber());
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPath1DPathEffect::Make(*path, advance, phase, style)));
+  }
+
+  JSI_HOST_FUNCTION(MakePath2D) {
+    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[0]);
+    auto path = JsiSkPath::fromValue(runtime, arguments[1]);
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkPath2DPathEffect::Make(*matrix, *path)));
+  }
+
+  JSI_HOST_FUNCTION(MakeLine2D) {
+    auto width = arguments[0].asNumber();
+    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[1]);
+
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPathEffect>(
+                    getContext(),  SkLine2DPathEffect::Make(width, *matrix)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCorner),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDash),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeDiscrete),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeCompose),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeSum),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakeLine2D),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath1D),
+    JSI_EXPORT_FUNC(JsiSkPathEffectFactory, MakePath2D),
+   )
+
+  JsiSkPathEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPathFactory.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPathEffect.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPath.h>
+#include <SkPathOps.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPathFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), SkPath()));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromSVGString) {
+    auto svgString = arguments[0].asString(runtime).utf8(runtime);
+    SkPath result;
+
+    if (!SkParsePath::FromSVGString(svgString.c_str(), &result)) {
+      jsi::detail::throwJSError(runtime, "Could not parse Svg path");
+      return jsi::Value(nullptr);
+    }
+
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromOp) {
+    SkPath one = *JsiSkPath::fromValue(runtime, arguments[0]).get();
+    SkPath two = *JsiSkPath::fromValue(runtime, arguments[1]).get();
+    SkPathOp op = (SkPathOp)arguments[2].asNumber();
+    SkPath result;
+    bool success = Op(one, two, op, &result);
+    if (!success) {
+      return jsi::Value(nullptr);
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathFactory, Make),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp))
+
+  JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPoint.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPoint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPoint : public JsiSkWrappingSharedPtrHostObject<SkPoint> {
+public:
+
+  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
+
+  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkPoint, x),
+                              JSI_EXPORT_PROP_GET(JsiSkPoint, y))
+
+  JsiSkPoint(std::shared_ptr<RNSkPlatformContext> context, const SkPoint &point)
+      : JsiSkWrappingSharedPtrHostObject<SkPoint>(
+            std::move(context), std::make_shared<SkPoint>(point)){}
+
+  /**
+  Returns the underlying object from a host object of this type
+ */
+  static std::shared_ptr<SkPoint> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return object
+              .asHostObject<JsiSkPoint>(runtime)
+              ->getObject();
+    } else {
+      auto x = object.getProperty(runtime, "x").asNumber();
+      auto y = object.getProperty(runtime, "y").asNumber();
+      return std::make_shared<SkPoint>(SkPoint::Make(x, y));
+    }
+  }
+
+  /**
+  Returns the jsi object from a host object of this type
+ */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkPoint &point) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPoint>(std::move(context), point));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkPoint
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkPoint
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      auto point =
+          SkPoint::Make(arguments[0].asNumber(), arguments[1].asNumber());
+
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkPoint>(std::move(context), std::move(point)));
+    };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkRRect.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRRect : public JsiSkWrappingSharedPtrHostObject<SkRRect> {
+public:
+  JSI_PROPERTY_GET(rx) {
+    return static_cast<double>(getObject()->getSimpleRadii().x());
+  }
+  JSI_PROPERTY_GET(ry) {
+    return static_cast<double>(getObject()->getSimpleRadii().y());
+  }
+  JSI_PROPERTY_GET(rect) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkRect>(getContext(), getObject()->getBounds()));
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkRRect, rx),
+                              JSI_EXPORT_PROP_GET(JsiSkRRect, ry),
+                              JSI_EXPORT_PROP_GET(JsiSkRRect, rect))
+
+  JsiSkRRect(std::shared_ptr<RNSkPlatformContext> context, const SkRRect &rect)
+      : JsiSkWrappingSharedPtrHostObject<SkRRect>(
+            std::move(context), std::make_shared<SkRRect>(rect)){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkRRect> fromValue(jsi::Runtime &runtime,
+                                            const jsi::Value &obj) {
+
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return obj.asObject(runtime)
+              .asHostObject<JsiSkRRect>(runtime)
+              ->getObject();
+    } else {
+      auto rect = JsiSkRect::fromValue(runtime, object.getProperty(runtime, "rect"));
+      auto rx = object.getProperty(runtime, "rx").asNumber();
+      auto ry = object.getProperty(runtime, "ry").asNumber();
+      return std::make_shared<SkRRect>(SkRRect::MakeRectXY(*rect, rx, ry));
+    }
+  }
+
+  /**
+    Returns the jsi object from a host object of this type
+   */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkRRect &rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRRect>(std::move(context), rect));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkRect
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkRect
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      // Set up the rect
+      auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+      auto rx = arguments[1].asNumber();
+      auto ry = arguments[2].asNumber();
+      auto rrect = SkRRect::MakeRectXY(*rect, rx, ry);
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkRRect>(std::move(context), std::move(rrect)));
+    };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkRSXform.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRSXform.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkRSXform : public JsiSkWrappingSharedPtrHostObject<SkRSXform> {
+    public:
+        JsiSkRSXform(std::shared_ptr<RNSkPlatformContext> context, const SkRSXform &rsxform)
+                : JsiSkWrappingSharedPtrHostObject<SkRSXform>(
+                std::move(context), std::make_shared<SkRSXform>(rsxform)){}
+
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+
+        JSI_PROPERTY_GET(__typename__) {
+          return jsi::String::createFromUtf8(runtime, "RSXform");
+        }
+
+        JSI_PROPERTY_GET(scos) {
+          return jsi::Value(SkScalarToDouble(getObject()->fSCos));
+        }
+        JSI_PROPERTY_GET(ssin) {
+          return jsi::Value(SkScalarToDouble(getObject()->fSSin));
+        }
+        JSI_PROPERTY_GET(tx) {
+          return jsi::Value(SkScalarToDouble(getObject()->fTx));
+        }
+        JSI_PROPERTY_GET(ty) {
+          return jsi::Value(SkScalarToDouble(getObject()->fTy));
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, __typename__),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, scos),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, ssin),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, tx),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, ty),
+        )
+
+        /**
+        Returns the underlying object from a host object of this type
+       */
+        static std::shared_ptr<SkRSXform> fromValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &obj) {
+            const auto& object = obj.asObject(runtime);
+            if (object.isHostObject(runtime)) {
+                return object
+                        .asHostObject<JsiSkRSXform>(runtime)
+                        ->getObject();
+            } else {
+                auto scos = object.getArray(runtime).getValueAtIndex(runtime, 0).asNumber();
+                auto ssin = object.getArray(runtime).getValueAtIndex(runtime, 1).asNumber();
+                auto tx = object.getArray(runtime).getValueAtIndex(runtime, 2).asNumber();
+                auto ty = object.getArray(runtime).getValueAtIndex(runtime, 3).asNumber();
+                return std::make_shared<SkRSXform>(SkRSXform::Make(scos, ssin, tx, ty));
+            }
+        }
+
+        /**
+        Returns the jsi object from a host object of this type
+       */
+        static jsi::Value toValue(jsi::Runtime &runtime,
+                                  std::shared_ptr<RNSkPlatformContext> context,
+                                  const SkRSXform &rsxform) {
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRSXform>(std::move(context), rsxform));
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkRSXform
+         * wrapper
+         * @param context platform context
+         * @return A function for creating a new host object wrapper for the SkRSXform
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+            return JSI_HOST_FUNCTION_LAMBDA {
+                    auto rsxform = SkRSXform::Make(
+                            arguments[0].asNumber(),
+                            arguments[1].asNumber(),
+                            arguments[2].asNumber(),
+                            arguments[3].asNumber()
+                    );
+                    // Return the newly constructed object
+                    return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRSXform>(std::move(context), std::move(rsxform)));
+            };
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkRect.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRect : public JsiSkWrappingSharedPtrHostObject<SkRect> {
+public:
+  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
+  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
+  JSI_PROPERTY_GET(width) { return static_cast<double>(getObject()->width()); }
+  JSI_PROPERTY_GET(height) {
+    return static_cast<double>(getObject()->height());
+  }
+  JSI_PROPERTY_GET(left) { return static_cast<double>(getObject()->left()); }
+  JSI_PROPERTY_GET(top) { return static_cast<double>(getObject()->top()); }
+  JSI_PROPERTY_GET(right) { return static_cast<double>(getObject()->right()); }
+  JSI_PROPERTY_GET(bottom) {
+    return static_cast<double>(getObject()->bottom());
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkRect, x),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, y),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, width),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, height))
+
+  JSI_HOST_FUNCTION(setXYWH) {
+    getObject()->setXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
+                         arguments[2].asNumber(), arguments[3].asNumber());
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(setLTRB) {
+    getObject()->setLTRB(arguments[0].asNumber(), arguments[1].asNumber(),
+                         arguments[2].asNumber(), arguments[3].asNumber());
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRect, setXYWH),
+                       JSI_EXPORT_FUNC(JsiSkRect, setLTRB), )
+
+  /**
+   Constructor
+   */
+  JsiSkRect(std::shared_ptr<RNSkPlatformContext> context, const SkRect &rect)
+      : JsiSkWrappingSharedPtrHostObject<SkRect>(
+            std::move(context), std::make_shared<SkRect>(rect)){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkRect> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return object
+              .asHostObject<JsiSkRect>(runtime)
+              ->getObject();
+    } else {
+      auto x = object.getProperty(runtime, "x").asNumber();
+      auto y = object.getProperty(runtime, "y").asNumber();
+      auto width = object.getProperty(runtime, "width").asNumber();
+      auto height = object.getProperty(runtime, "height").asNumber();
+      return std::make_shared<SkRect>(SkRect::MakeXYWH(x, y, width, height));
+    }
+  }
+
+  /**
+    Returns the jsi object from a host object of this type
+   */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkRect &rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(std::move(context), rect));
+  }
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            SkRect&& rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(std::move(context), std::move(rect)));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkRect
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkRect
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      // Set up the rect
+      SkRect rect =
+          SkRect::MakeXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
+                           arguments[2].asNumber(), arguments[3].asNumber());
+
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkRect>(std::move(context), std::move(rect)));
+    };
+  }
+};
+} // namespace RNSkia