@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkPath.h

@@ -0,0 +1,557 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRRect.h"
+#include "JsiSkRect.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkDashPathEffect.h>
+#include <SkParsePath.h>
+#include <SkPath.h>
+#include <SkPathOps.h>
+#include <SkPathTypes.h>
+#include <SkStrokeRec.h>
+#include <SkTextUtils.h>
+#include <SkTrimPathEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkPath : public JsiSkWrappingSharedPtrHostObject<SkPath> {
+public:
+
+    // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+    JSI_PROPERTY_GET(__typename__) {
+      return jsi::String::createFromUtf8(runtime, "Path");
+    }
+
+    JSI_HOST_FUNCTION(addArc) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+    auto start = arguments[1].asNumber();
+    auto sweep = arguments[2].asNumber();
+    getObject()->addArc(*rect, start, sweep);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addOval) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    unsigned startIndex = count < 3 ? 0 : arguments[2].asNumber();
+    getObject()->addOval(*rect, direction, startIndex);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addPoly) {
+    std::vector<SkPoint> points;
+    auto jsiPoints = arguments[0].asObject(runtime).asArray(runtime);
+    auto close = arguments[1].getBool();
+    auto pointsSize = jsiPoints.size(runtime);
+    points.reserve(pointsSize);
+    for (int i = 0; i < pointsSize; i++) {
+      std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
+          runtime, jsiPoints.getValueAtIndex(runtime, i).asObject(runtime));
+      points.push_back(*point.get());
+    }
+    getObject()->addPoly(points.data(), (int)points.size(), close);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addRect) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    getObject()->addRect(*rect, direction);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addRRect) {
+    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]).get();
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    getObject()->addRRect(*rrect, direction);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(arcToOval) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]).get();
+    auto start = arguments[1].asNumber();
+    auto sweep = arguments[2].asNumber();
+    auto forceMoveTo = arguments[3].getBool();
+    getObject()->arcTo(*rect, start, sweep, forceMoveTo);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(arcToRotated) {
+    auto rx = arguments[0].asNumber();
+    auto ry = arguments[1].asNumber();
+    auto xAxisRotate = arguments[2].asNumber();
+    auto useSmallArc = arguments[3].getBool();
+    auto arcSize = useSmallArc ? SkPath::ArcSize::kSmall_ArcSize
+                               : SkPath::ArcSize::kLarge_ArcSize;
+    auto sweep =
+        arguments[4].getBool() ? SkPathDirection::kCCW : SkPathDirection::kCW;
+    auto x = arguments[5].asNumber();
+    auto y = arguments[6].asNumber();
+    getObject()->arcTo(rx, ry, xAxisRotate, arcSize, sweep, x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rArcTo) {
+    auto rx = arguments[0].asNumber();
+    auto ry = arguments[1].asNumber();
+    auto xAxisRotate = arguments[2].asNumber();
+    auto useSmallArc = arguments[3].getBool();
+    auto arcSize = useSmallArc ? SkPath::ArcSize::kSmall_ArcSize
+                               : SkPath::ArcSize::kLarge_ArcSize;
+    auto sweep =
+        arguments[4].getBool() ? SkPathDirection::kCCW : SkPathDirection::kCW;
+    auto x = arguments[5].asNumber();
+    auto y = arguments[6].asNumber();
+    getObject()->rArcTo(rx, ry, xAxisRotate, arcSize, sweep, x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(arcToTangent) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    auto r = arguments[4].asNumber();
+    getObject()->arcTo(x1, y1, x2, y2, r);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(computeTightBounds) {
+    auto result = getObject()->computeTightBounds();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(result)));
+  }
+
+  // TODO-API: Should this be a property?
+  JSI_HOST_FUNCTION(getBounds) {
+    auto result = getObject()->getBounds();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(result)));
+  }
+
+  JSI_HOST_FUNCTION(conicTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    auto w = arguments[4].asNumber();
+    getObject()->conicTo(x1, y1, x2, y2, w);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rConicTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    auto w = arguments[4].asNumber();
+    getObject()->rConicTo(x1, y1, x2, y2, w);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(contains) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    return jsi::Value(getObject()->contains(x, y));
+  }
+
+  JSI_HOST_FUNCTION(dash) {
+    SkScalar on = arguments[0].asNumber();
+    SkScalar off = arguments[1].asNumber();
+    auto phase = arguments[2].asNumber();
+    SkScalar intervals[] = {on, off};
+    auto pe = SkDashPathEffect::Make(intervals, 2, phase);
+    if (!pe) {
+      // TODO: SkDebugf("Invalid args to dash()\n");
+      return jsi::Value(false);
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    SkPath &path = *getObject();
+    // TODO: why we don't need to swap here? In trim() which is the same
+    // API, we need to swap
+    if (pe->filterPath(&path, path, &rec, nullptr)) {
+      return jsi::Value(true);
+    }
+    SkDebugf("Could not make dashed path\n");
+    return jsi::Value(false);
+  }
+
+  JSI_HOST_FUNCTION(equals) {
+    auto p1 = JsiSkPath::fromValue(runtime, arguments[0]).get();
+    auto p2 = JsiSkPath::fromValue(runtime, arguments[1]).get();
+    return jsi::Value(p1 == p2);
+  }
+
+  // TODO-API: Property?
+  JSI_HOST_FUNCTION(getFillType) {
+    auto fillType = getObject()->getFillType();
+    return jsi::Value(static_cast<int>(fillType));
+  }
+
+  // TODO-API: Property?
+  JSI_HOST_FUNCTION(setFillType) {
+    auto ft = (SkPathFillType)arguments[0].asNumber();
+    getObject()->setFillType(ft);
+    return jsi::Value::undefined();
+  }
+
+  // TODO-API: Property?
+  JSI_HOST_FUNCTION(setIsVolatile) {
+    auto v = arguments[0].getBool();
+    getObject()->setIsVolatile(v);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(isVolatile) {
+    return jsi::Value(getObject()->isVolatile());
+  }
+
+  JSI_HOST_FUNCTION(transform) {
+    auto m3 = *JsiSkMatrix::fromValue(runtime, arguments[0]);
+    getObject()->transform(m3);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(stroke) {
+    auto path = *getObject();
+    auto opts = arguments[0].asObject(runtime);
+    SkPaint p;
+    p.setStyle(SkPaint::kStroke_Style);
+
+    auto jsiCap = opts.getProperty(runtime, "cap");
+    if (!jsiCap.isUndefined()) {
+      auto cap = (SkPaint::Cap)jsiCap.asNumber();
+      p.setStrokeCap(cap);
+    }
+
+    auto jsiJoin = opts.getProperty(runtime, "join");
+    if (!jsiJoin.isUndefined()) {
+      auto join = (SkPaint::Join)jsiJoin.asNumber();
+      p.setStrokeJoin(join);
+    }
+
+    auto jsiWidth = opts.getProperty(runtime, "width");
+    if (!jsiWidth.isUndefined()) {
+      auto width = jsiWidth.asNumber();
+      p.setStrokeWidth(width);
+    }
+
+    auto jsiMiterLimit = opts.getProperty(runtime, "miter_limit");
+    if (!jsiMiterLimit.isUndefined()) {
+      auto miter_limit = opts.getProperty(runtime, "miter_limit").asNumber();
+      p.setStrokeMiter(miter_limit);
+    }
+
+    auto jsiPrecision = opts.getProperty(runtime, "precision");
+    auto precision = jsiPrecision.isUndefined() ? 1 : jsiPrecision.asNumber();
+    auto result = p.getFillPath(path, &path, nullptr, precision);
+    getObject()->swap(path);
+    return jsi::Value(result);
+  }
+
+  JSI_HOST_FUNCTION(trim) {
+    auto start = arguments[0].asNumber();
+    auto end = arguments[1].asNumber();
+    auto isComplement = arguments[2].getBool();
+    auto path = *getObject();
+    auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
+                             : SkTrimPathEffect::Mode::kNormal;
+    auto pe = SkTrimPathEffect::Make(start, end, mode);
+    if (!pe) {
+      // SkDebugf("Invalid args to trim(): startT and stopT must be in
+      // [0,1]\n");
+      return jsi::Value(false);
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    if (pe->filterPath(&path, path, &rec, nullptr)) {
+      getObject()->swap(path);
+      return jsi::Value(true);
+    }
+    SkDebugf("Could not trim path\n");
+    return jsi::Value(false);
+  }
+
+  JSI_HOST_FUNCTION(getPoint) {
+    auto index = arguments[0].asNumber();
+    auto point = getObject()->getPoint(index);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPoint>(getContext(), point));
+  }
+
+  JSI_HOST_FUNCTION(toSVGString) {
+    SkPath path = *getObject();
+    SkString s;
+    SkParsePath::ToSVGString(path, &s);
+    return jsi::String::createFromUtf8(runtime, s.c_str());
+  }
+
+  JSI_HOST_FUNCTION(makeAsWinding) {
+    SkPath out;
+    if (AsWinding(*getObject(), &out)) {
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkPath>(getContext(), std::move(out)));
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(isEmpty) { return jsi::Value(getObject()->isEmpty()); }
+
+  JSI_HOST_FUNCTION(offset) {
+    SkScalar dx = arguments[0].asNumber();
+    SkScalar dy = arguments[1].asNumber();
+    getObject()->offset(dx, dy);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(moveTo) {
+    SkScalar x = arguments[0].asNumber();
+    SkScalar y = arguments[1].asNumber();
+    getObject()->moveTo(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rMoveTo) {
+    SkScalar x = arguments[0].asNumber();
+    SkScalar y = arguments[1].asNumber();
+    getObject()->rMoveTo(x, y);
+    return jsi::Value::undefined();
+  }
+  JSI_HOST_FUNCTION(lineTo) {
+    SkScalar x = arguments[0].asNumber();
+    SkScalar y = arguments[1].asNumber();
+    getObject()->lineTo(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rlineTo) {
+    SkScalar x = arguments[0].asNumber();
+    SkScalar y = arguments[1].asNumber();
+    getObject()->rLineTo(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(cubicTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    auto x3 = arguments[4].asNumber();
+    auto y3 = arguments[5].asNumber();
+    getObject()->cubicTo(x1, y1, x2, y2, x3, y3);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rCubicTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    auto x3 = arguments[4].asNumber();
+    auto y3 = arguments[5].asNumber();
+    getObject()->rCubicTo(x1, y1, x2, y2, x3, y3);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(reset) {
+    getObject()->reset();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rewind) {
+    getObject()->rewind();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(quadTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    getObject()->quadTo(x1, y1, x2, y2);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rQuadTo) {
+    auto x1 = arguments[0].asNumber();
+    auto y1 = arguments[1].asNumber();
+    auto x2 = arguments[2].asNumber();
+    auto y2 = arguments[3].asNumber();
+    getObject()->rQuadTo(x1, y1, x2, y2);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addCircle) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    auto r = arguments[2].asNumber();
+    getObject()->addCircle(x, y, r);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getLastPt) {
+    SkPoint last;
+    getObject()->getLastPt(&last);
+    auto point = jsi::Object(runtime);
+    point.setProperty(runtime, "x", static_cast<double>(last.fX));
+    point.setProperty(runtime, "y", static_cast<double>(last.fY));
+    return point;
+  }
+
+  JSI_HOST_FUNCTION(close) {
+    getObject()->close();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(simplify) {
+    SkPath result;
+    if (Simplify(*getObject(), &result)) {
+      getObject()->swap(result);
+      return jsi::Value(true);
+    }
+    return jsi::Value(false);
+  }
+
+  JSI_HOST_FUNCTION(countPoints) {
+    auto points = getObject()->countPoints();
+    return jsi::Value(points);
+  }
+
+  JSI_HOST_FUNCTION(copy) {
+    const auto* path = getObject().get();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), SkPath(*path)));
+  }
+
+  JSI_HOST_FUNCTION(fromText) {
+    auto text = arguments[0].asString(runtime).utf8(runtime);
+    auto x = arguments[1].asNumber();
+    auto y = arguments[2].asNumber();
+    auto font = JsiSkFont::fromValue(runtime, arguments[3]);
+    SkPath result;
+    SkTextUtils::GetPath(text.c_str(), strlen(text.c_str()),
+                         SkTextEncoding::kUTF8, x, y, *font, &result);
+
+    getObject()->swap(result);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(op) {
+    auto path2 = JsiSkPath::fromValue(runtime, arguments[0]);
+    int pathOp = arguments[1].asNumber();
+    SkPath result;
+    if (Op(*getObject(), *path2, SkPathOp(pathOp), &result)) {
+      getObject()->swap(result);
+      return jsi::Value(true);
+    }
+    return jsi::Value(false);
+  }
+
+  JSI_HOST_FUNCTION(isInterpolatable) {
+    auto path2 = JsiSkPath::fromValue(runtime, arguments[0]);
+    return getObject()->isInterpolatable(*path2);
+  }
+
+  JSI_HOST_FUNCTION(interpolate) {
+    auto path2 = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto weight = arguments[1].asNumber();
+    SkPath result;
+    getObject()->interpolate(*path2, weight, &result);
+    return jsi::Object::createFromHostObject(
+            runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkPath, __typename__))
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkPath, addArc), JSI_EXPORT_FUNC(JsiSkPath, addOval),
+    JSI_EXPORT_FUNC(JsiSkPath, addPoly), JSI_EXPORT_FUNC(JsiSkPath, addRect),
+    JSI_EXPORT_FUNC(JsiSkPath, addRRect),
+    JSI_EXPORT_FUNC(JsiSkPath, arcToOval),
+    JSI_EXPORT_FUNC(JsiSkPath, arcToRotated),
+    JSI_EXPORT_FUNC(JsiSkPath, rArcTo),
+    JSI_EXPORT_FUNC(JsiSkPath, arcToTangent),
+    JSI_EXPORT_FUNC(JsiSkPath, computeTightBounds),
+    JSI_EXPORT_FUNC(JsiSkPath, getBounds),
+    JSI_EXPORT_FUNC(JsiSkPath, conicTo), JSI_EXPORT_FUNC(JsiSkPath, rConicTo),
+    JSI_EXPORT_FUNC(JsiSkPath, contains), JSI_EXPORT_FUNC(JsiSkPath, dash),
+    JSI_EXPORT_FUNC(JsiSkPath, equals),
+    JSI_EXPORT_FUNC(JsiSkPath, getFillType),
+    JSI_EXPORT_FUNC(JsiSkPath, setFillType),
+    JSI_EXPORT_FUNC(JsiSkPath, setIsVolatile),
+    JSI_EXPORT_FUNC(JsiSkPath, isVolatile),
+    JSI_EXPORT_FUNC(JsiSkPath, transform), JSI_EXPORT_FUNC(JsiSkPath, stroke),
+    JSI_EXPORT_FUNC(JsiSkPath, trim), JSI_EXPORT_FUNC(JsiSkPath, getPoint),
+    JSI_EXPORT_FUNC(JsiSkPath, toSVGString),
+    JSI_EXPORT_FUNC(JsiSkPath, makeAsWinding),
+    JSI_EXPORT_FUNC(JsiSkPath, isEmpty), JSI_EXPORT_FUNC(JsiSkPath, offset),
+    JSI_EXPORT_FUNC(JsiSkPath, moveTo), JSI_EXPORT_FUNC(JsiSkPath, rMoveTo),
+    JSI_EXPORT_FUNC(JsiSkPath, lineTo), JSI_EXPORT_FUNC(JsiSkPath, rlineTo),
+    JSI_EXPORT_FUNC(JsiSkPath, cubicTo), JSI_EXPORT_FUNC(JsiSkPath, rCubicTo),
+    JSI_EXPORT_FUNC(JsiSkPath, reset), JSI_EXPORT_FUNC(JsiSkPath, rewind),
+    JSI_EXPORT_FUNC(JsiSkPath, quadTo), JSI_EXPORT_FUNC(JsiSkPath, rQuadTo),
+    JSI_EXPORT_FUNC(JsiSkPath, addCircle),
+    JSI_EXPORT_FUNC(JsiSkPath, getLastPt), JSI_EXPORT_FUNC(JsiSkPath, close),
+    JSI_EXPORT_FUNC(JsiSkPath, simplify),
+    JSI_EXPORT_FUNC(JsiSkPath, countPoints), JSI_EXPORT_FUNC(JsiSkPath, copy),
+    JSI_EXPORT_FUNC(JsiSkPath, fromText), JSI_EXPORT_FUNC(JsiSkPath, op),
+    JSI_EXPORT_FUNC(JsiSkPath, isInterpolatable), JSI_EXPORT_FUNC(JsiSkPath, interpolate)
+  )
+
+  JsiSkPath(std::shared_ptr<RNSkPlatformContext> context, SkPath path)
+      : JsiSkWrappingSharedPtrHostObject<SkPath>(
+            std::move(context), std::make_shared<SkPath>(std::move(path))){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkPath> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkPath>(runtime)
+        ->getObject();
+  }
+
+    static jsi::Value toValue(jsi::Runtime &runtime,
+                              std::shared_ptr<RNSkPlatformContext> context,
+                              const SkPath &path) {
+      return jsi::Object::createFromHostObject(
+              runtime,
+              std::make_shared<JsiSkPath>(std::move(context), path)
+      );
+    }
+
+    static jsi::Value toValue(jsi::Runtime &runtime,
+                              std::shared_ptr<RNSkPlatformContext> context,
+                              SkPath&& path) {
+      return jsi::Object::createFromHostObject(
+              runtime,
+              std::make_shared<JsiSkPath>(std::move(context), std::move(path))
+      );
+    }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkPathEffect.h

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