@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

package/cpp/api/JsiSkCanvas.h

@@ -1,9 +1,11 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFont.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageInfo.h"
@@ -53,29 +55,21 @@ class JsiSkCanvas : public JsiSkNativeObject<JsiSkCanvas> {
 public:
   static constexpr const char *CLASS_NAME = "Canvas";
 
-  JSI_HOST_FUNCTION(drawPaint) {
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[0]);
+  void drawPaint(std::shared_ptr<SkPaint> paint) {
     _canvas->drawPaint(*paint);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawLine) {
-    SkScalar x1 = arguments[0].asNumber();
-    SkScalar y1 = arguments[1].asNumber();
-    SkScalar x2 = arguments[2].asNumber();
-    SkScalar y2 = arguments[3].asNumber();
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[4]);
+  void drawLine(double x1, double y1, double x2, double y2,
+                std::shared_ptr<SkPaint> paint) {
     _canvas->drawLine(x1, y1, x2, y2, *paint);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawRect) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
+  void drawRect(std::shared_ptr<SkRect> rect, std::shared_ptr<SkPaint> paint) {
     _canvas->drawRect(*rect, *paint);
-    return jsi::Value::undefined();
   }
 
+  // The drawImage* variants stay raw: they dispatch on exact argument counts
+  // (count == 4 / count == 6) with null-tolerant trailing paints.
   JSI_HOST_FUNCTION(drawImage) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
     auto x = arguments[1].asNumber();
@@ -185,106 +179,55 @@ public:
     return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawCircle) {
-    SkScalar cx = arguments[0].asNumber();
-    SkScalar cy = arguments[1].asNumber();
-    SkScalar radius = arguments[2].asNumber();
-
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
+  void drawCircle(double cx, double cy, double radius,
+                  std::shared_ptr<SkPaint> paint) {
     _canvas->drawCircle(cx, cy, radius, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawArc) {
-    auto oval = JsiSkRect::fromValue(runtime, arguments[0]);
-
-    SkScalar startAngle = arguments[1].asNumber();
-    SkScalar sweepAngle = arguments[2].asNumber();
-    bool useCenter = arguments[3].getBool();
-
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[4]);
+  void drawArc(std::shared_ptr<SkRect> oval, double startAngle,
+               double sweepAngle, bool useCenter,
+               std::shared_ptr<SkPaint> paint) {
     _canvas->drawArc(*oval, startAngle, sweepAngle, useCenter, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawRRect) {
-    auto rect = JsiSkRRect::fromValue(runtime, arguments[0]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-
+  void drawRRect(std::shared_ptr<SkRRect> rect,
+                 std::shared_ptr<SkPaint> paint) {
     _canvas->drawRRect(*rect, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawDRRect) {
-    auto outer = JsiSkRRect::fromValue(runtime, arguments[0]);
-    auto inner = JsiSkRRect::fromValue(runtime, arguments[1]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[2]);
-
+  void drawDRRect(std::shared_ptr<SkRRect> outer,
+                  std::shared_ptr<SkRRect> inner,
+                  std::shared_ptr<SkPaint> paint) {
     _canvas->drawDRRect(*outer, *inner, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawOval) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-
+  void drawOval(std::shared_ptr<SkRect> rect, std::shared_ptr<SkPaint> paint) {
     _canvas->drawOval(*rect, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(restoreToCount) {
-    auto c = arguments[0].asNumber();
-    _canvas->restoreToCount(c);
-    return jsi::Value::undefined();
-  }
+  void restoreToCount(double c) { _canvas->restoreToCount(c); }
 
-  JSI_HOST_FUNCTION(getSaveCount) {
-    return static_cast<int>(_canvas->getSaveCount());
-  }
+  int getSaveCount() { return static_cast<int>(_canvas->getSaveCount()); }
 
-  JSI_HOST_FUNCTION(getTotalMatrix) {
-    return makeJsiObject(runtime, std::make_shared<JsiSkMatrix>(
-                                      getContext(), _canvas->getTotalMatrix()));
+  std::shared_ptr<JsiSkMatrix> getTotalMatrix() {
+    return std::make_shared<JsiSkMatrix>(getContext(),
+                                         _canvas->getTotalMatrix());
   }
 
-  JSI_HOST_FUNCTION(drawPoints) {
-    auto pointMode = arguments[0].asNumber();
-    std::vector<SkPoint> points;
-
-    auto jsiPoints = arguments[1].asObject(runtime).asArray(runtime);
-    auto pointsSize = jsiPoints.size(runtime);
-
+  void drawPoints(double pointMode, std::vector<SkPoint> points,
+                  std::shared_ptr<SkPaint> paint) {
     // Check if we have at least one point
-    if (pointsSize == 0) {
+    if (points.empty()) {
       throw std::invalid_argument("Points array must not be empty");
     }
-
-    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());
-    }
-
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[2]);
     auto p = SkSpan(points.data(), points.size());
-    _canvas->drawPoints((SkCanvas::PointMode)pointMode, p, *paint);
-
-    return jsi::Value::undefined();
+    _canvas->drawPoints(static_cast<SkCanvas::PointMode>(pointMode), p, *paint);
   }
 
-  JSI_HOST_FUNCTION(drawVertices) {
-    auto vertices = JsiSkVertices::fromValue(runtime, arguments[0]);
-    auto blendMode = (SkBlendMode)arguments[1].getNumber();
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[2]);
-    _canvas->drawVertices(vertices, blendMode, *paint);
-    return jsi::Value::undefined();
+  void drawVertices(sk_sp<SkVertices> vertices, double blendMode,
+                    std::shared_ptr<SkPaint> paint) {
+    _canvas->drawVertices(vertices, static_cast<SkBlendMode>(blendMode),
+                          *paint);
   }
 
   JSI_HOST_FUNCTION(drawPatch) {
@@ -352,118 +295,71 @@ public:
     return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawPath) {
-    auto path = JsiSkPath::fromValue(runtime, arguments[0]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-
+  void drawPath(std::shared_ptr<SkPathBuilder> path,
+                std::shared_ptr<SkPaint> paint) {
     _canvas->drawPath(path->snapshot(), *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawText) {
-    auto textVal = arguments[0].asString(runtime).utf8(runtime);
+  void drawText(std::string textVal, double x, double y,
+                std::shared_ptr<SkPaint> paint, std::shared_ptr<SkFont> font) {
     auto text = textVal.c_str();
-    SkScalar x = arguments[1].asNumber();
-    SkScalar y = arguments[2].asNumber();
-
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
-    auto font = JsiSkFont::fromValue(runtime, arguments[4]);
-
     _canvas->drawSimpleText(text, strlen(text), SkTextEncoding::kUTF8, x, y,
                             *font, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawTextBlob) {
-    auto blob = JsiSkTextBlob::fromValue(runtime, arguments[0]);
-    SkScalar x = arguments[1].asNumber();
-    SkScalar y = arguments[2].asNumber();
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
+  void drawTextBlob(sk_sp<SkTextBlob> blob, double x, double y,
+                    std::shared_ptr<SkPaint> paint) {
     _canvas->drawTextBlob(blob, x, y, *paint);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawGlyphs) {
-    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
-    auto jsiPositions = arguments[1].asObject(runtime).asArray(runtime);
-    auto x = arguments[2].asNumber();
-    auto y = arguments[3].asNumber();
-    auto font = JsiSkFont::fromValue(runtime, arguments[4]);
-    auto paint = JsiSkPaint::fromValue(runtime, arguments[5]);
+  void drawGlyphs(std::vector<int> glyphIds, std::vector<SkPoint> positions,
+                  double x, double y, std::shared_ptr<SkFont> font,
+                  std::shared_ptr<SkPaint> paint) {
     SkPoint origin = SkPoint::Make(x, y);
 
-    std::vector<SkPoint> positions;
-    int pointsSize = static_cast<int>(jsiPositions.size(runtime));
-    positions.reserve(pointsSize);
-    for (int i = 0; i < pointsSize; i++) {
-      std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
-          runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
-      positions.push_back(*point.get());
-    }
-
-    std::vector<SkGlyphID> glyphs;
-    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
-
     // Validate that glyphs and positions arrays have the same size
-    if (glyphsSize != pointsSize) {
+    if (glyphIds.size() != positions.size()) {
       throw std::invalid_argument(
           "Glyphs and positions arrays must have the same length");
     }
 
-    glyphs.reserve(glyphsSize);
-    for (int i = 0; i < glyphsSize; i++) {
-      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+    std::vector<SkGlyphID> glyphs;
+    glyphs.reserve(glyphIds.size());
+    for (auto glyph : glyphIds) {
+      glyphs.push_back(static_cast<SkGlyphID>(glyph));
     }
 
     auto g = SkSpan(glyphs.data(), glyphs.size());
     auto p = SkSpan(positions.data(), positions.size());
     _canvas->drawGlyphs(g, p, origin, *font, *paint);
-
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(drawSvg) {
-    auto svgdom = JsiSkSVG::fromValue(runtime, arguments[0]);
-    if (count == 3 && arguments[1].isNumber() && arguments[2].isNumber()) {
-      // read size
-      auto w = arguments[1].asNumber();
-      auto h = arguments[2].asNumber();
-      svgdom->setContainerSize(SkSize::Make(w, h));
+  void drawSvg(sk_sp<SkSVGDOM> svgdom, JsiOptional<double> w,
+               JsiOptional<double> h) {
+    if (w.has_value() && h.has_value()) {
+      svgdom->setContainerSize(SkSize::Make(*w, *h));
     } else {
       auto canvasSize = _canvas->getBaseLayerSize();
       svgdom->setContainerSize(SkSize::Make(canvasSize));
     }
     svgdom->render(_canvas);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(clipPath) {
-    auto path = JsiSkPath::fromValue(runtime, arguments[0]);
-    auto op = (SkClipOp)arguments[1].asNumber();
-    auto doAntiAlias = arguments[2].getBool();
-    _canvas->clipPath(path->snapshot(), op, doAntiAlias);
-    return jsi::Value::undefined();
+  void clipPath(std::shared_ptr<SkPathBuilder> path, double op,
+                bool doAntiAlias) {
+    _canvas->clipPath(path->snapshot(), static_cast<SkClipOp>(op),
+                      doAntiAlias);
   }
 
-  JSI_HOST_FUNCTION(clipRect) {
-    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-    auto op = (SkClipOp)arguments[1].asNumber();
-    auto doAntiAlias = arguments[2].getBool();
-    _canvas->clipRect(*rect, op, doAntiAlias);
-    return jsi::Value::undefined();
+  void clipRect(std::shared_ptr<SkRect> rect, double op, bool doAntiAlias) {
+    _canvas->clipRect(*rect, static_cast<SkClipOp>(op), doAntiAlias);
   }
 
-  JSI_HOST_FUNCTION(clipRRect) {
-    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]);
-    auto op = (SkClipOp)arguments[1].asNumber();
-    auto doAntiAlias = arguments[2].getBool();
-    _canvas->clipRRect(*rrect, op, doAntiAlias);
-    return jsi::Value::undefined();
+  void clipRRect(std::shared_ptr<SkRRect> rrect, double op, bool doAntiAlias) {
+    _canvas->clipRRect(*rrect, static_cast<SkClipOp>(op), doAntiAlias);
   }
 
-  JSI_HOST_FUNCTION(save) { return jsi::Value(_canvas->save()); }
+  int save() { return _canvas->save(); }
 
   JSI_HOST_FUNCTION(saveLayer) {
     SkPaint *paint = (count >= 1 && !arguments[0].isUndefined())
@@ -482,67 +378,32 @@ public:
         SkCanvas::SaveLayerRec(bounds, paint, backdrop, flags)));
   }
 
-  JSI_HOST_FUNCTION(restore) {
-    _canvas->restore();
-    return jsi::Value::undefined();
-  }
+  void restore() { _canvas->restore(); }
 
-  JSI_HOST_FUNCTION(rotate) {
-    SkScalar degrees = arguments[0].asNumber();
-    SkScalar rx = arguments[1].asNumber();
-    SkScalar ry = arguments[2].asNumber();
+  void rotate(double degrees, double rx, double ry) {
     _canvas->rotate(degrees, rx, ry);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(translate) {
-    SkScalar dx = arguments[0].asNumber();
-    SkScalar dy = arguments[1].asNumber();
-    _canvas->translate(dx, dy);
-    return jsi::Value::undefined();
-  }
+  void translate(double dx, double dy) { _canvas->translate(dx, dy); }
 
-  JSI_HOST_FUNCTION(scale) {
-    SkScalar sx = arguments[0].asNumber();
-    SkScalar sy = arguments[1].asNumber();
-    _canvas->scale(sx, sy);
-    return jsi::Value::undefined();
-  }
+  void scale(double sx, double sy) { _canvas->scale(sx, sy); }
 
-  JSI_HOST_FUNCTION(skew) {
-    SkScalar sx = arguments[0].asNumber();
-    SkScalar sy = arguments[1].asNumber();
-    _canvas->skew(sx, sy);
-    return jsi::Value::undefined();
-  }
+  void skew(double sx, double sy) { _canvas->skew(sx, sy); }
 
-  JSI_HOST_FUNCTION(drawColor) {
-    SkColor cl = JsiSkColor::fromValue(runtime, arguments[0]);
-    if (count == 1) {
-      _canvas->drawColor(cl);
+  void drawColor(JsiColor cl, JsiOptional<double> mode) {
+    if (mode.has_value()) {
+      _canvas->drawColor(cl, static_cast<SkBlendMode>(*mode));
     } else {
-      auto mode = static_cast<SkBlendMode>(arguments[1].asNumber());
-      _canvas->drawColor(cl, mode);
+      _canvas->drawColor(cl);
     }
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(clear) {
-    SkColor cl = JsiSkColor::fromValue(runtime, arguments[0]);
-    _canvas->clear(cl);
-    return jsi::Value::undefined();
-  }
+  void clear(JsiColor cl) { _canvas->clear(cl); }
 
-  JSI_HOST_FUNCTION(concat) {
-    auto matrix = JsiSkMatrix::fromValue(runtime, arguments[0]);
-    _canvas->concat(*matrix.get());
-    return jsi::Value::undefined();
-  }
+  void concat(std::shared_ptr<SkMatrix> matrix) { _canvas->concat(*matrix); }
 
-  JSI_HOST_FUNCTION(drawPicture) {
-    auto picture = JsiSkPicture::fromValue(runtime, arguments[0]);
+  void drawPicture(sk_sp<SkPicture> picture) {
     _canvas->drawPicture(picture);
-    return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(drawAtlas) {
@@ -679,9 +540,9 @@ public:
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "drawPaint", &JsiSkCanvas::drawPaint);
-    installHostMethod(runtime, prototype, "drawLine", &JsiSkCanvas::drawLine);
-    installHostMethod(runtime, prototype, "drawRect", &JsiSkCanvas::drawRect);
+    installMethod(runtime, prototype, "drawPaint", &JsiSkCanvas::drawPaint);
+    installMethod(runtime, prototype, "drawLine", &JsiSkCanvas::drawLine);
+    installMethod(runtime, prototype, "drawRect", &JsiSkCanvas::drawRect);
     installHostMethod(runtime, prototype, "drawImage", &JsiSkCanvas::drawImage);
     installHostMethod(runtime, prototype, "drawImageRect",
                       &JsiSkCanvas::drawImageRect);
@@ -695,46 +556,42 @@ public:
                       &JsiSkCanvas::drawImageRectCubic);
     installHostMethod(runtime, prototype, "drawImageRectOptions",
                       &JsiSkCanvas::drawImageRectOptions);
-    installHostMethod(runtime, prototype, "drawCircle",
-                      &JsiSkCanvas::drawCircle);
-    installHostMethod(runtime, prototype, "drawArc", &JsiSkCanvas::drawArc);
-    installHostMethod(runtime, prototype, "drawRRect", &JsiSkCanvas::drawRRect);
-    installHostMethod(runtime, prototype, "drawDRRect",
-                      &JsiSkCanvas::drawDRRect);
-    installHostMethod(runtime, prototype, "drawOval", &JsiSkCanvas::drawOval);
-    installHostMethod(runtime, prototype, "restoreToCount",
-                      &JsiSkCanvas::restoreToCount);
-    installHostMethod(runtime, prototype, "getSaveCount",
-                      &JsiSkCanvas::getSaveCount);
-    installHostMethod(runtime, prototype, "getTotalMatrix",
-                      &JsiSkCanvas::getTotalMatrix);
-    installHostMethod(runtime, prototype, "drawPoints",
-                      &JsiSkCanvas::drawPoints);
+    installMethod(runtime, prototype, "drawCircle", &JsiSkCanvas::drawCircle);
+    installMethod(runtime, prototype, "drawArc", &JsiSkCanvas::drawArc);
+    installMethod(runtime, prototype, "drawRRect", &JsiSkCanvas::drawRRect);
+    installMethod(runtime, prototype, "drawDRRect", &JsiSkCanvas::drawDRRect);
+    installMethod(runtime, prototype, "drawOval", &JsiSkCanvas::drawOval);
+    installMethod(runtime, prototype, "restoreToCount",
+                  &JsiSkCanvas::restoreToCount);
+    installMethod(runtime, prototype, "getSaveCount",
+                  &JsiSkCanvas::getSaveCount);
+    installMethod(runtime, prototype, "getTotalMatrix",
+                  &JsiSkCanvas::getTotalMatrix);
+    installMethod(runtime, prototype, "drawPoints", &JsiSkCanvas::drawPoints);
     installHostMethod(runtime, prototype, "drawPatch", &JsiSkCanvas::drawPatch);
-    installHostMethod(runtime, prototype, "drawPath", &JsiSkCanvas::drawPath);
-    installHostMethod(runtime, prototype, "drawVertices",
-                      &JsiSkCanvas::drawVertices);
-    installHostMethod(runtime, prototype, "drawText", &JsiSkCanvas::drawText);
-    installHostMethod(runtime, prototype, "drawTextBlob",
-                      &JsiSkCanvas::drawTextBlob);
-    installHostMethod(runtime, prototype, "drawGlyphs",
-                      &JsiSkCanvas::drawGlyphs);
-    installHostMethod(runtime, prototype, "drawSvg", &JsiSkCanvas::drawSvg);
-    installHostMethod(runtime, prototype, "clipPath", &JsiSkCanvas::clipPath);
-    installHostMethod(runtime, prototype, "clipRect", &JsiSkCanvas::clipRect);
-    installHostMethod(runtime, prototype, "clipRRect", &JsiSkCanvas::clipRRect);
-    installHostMethod(runtime, prototype, "save", &JsiSkCanvas::save);
+    installMethod(runtime, prototype, "drawPath", &JsiSkCanvas::drawPath);
+    installMethod(runtime, prototype, "drawVertices",
+                  &JsiSkCanvas::drawVertices);
+    installMethod(runtime, prototype, "drawText", &JsiSkCanvas::drawText);
+    installMethod(runtime, prototype, "drawTextBlob",
+                  &JsiSkCanvas::drawTextBlob);
+    installMethod(runtime, prototype, "drawGlyphs", &JsiSkCanvas::drawGlyphs);
+    installMethod(runtime, prototype, "drawSvg", &JsiSkCanvas::drawSvg);
+    installMethod(runtime, prototype, "clipPath", &JsiSkCanvas::clipPath);
+    installMethod(runtime, prototype, "clipRect", &JsiSkCanvas::clipRect);
+    installMethod(runtime, prototype, "clipRRect", &JsiSkCanvas::clipRRect);
+    installMethod(runtime, prototype, "save", &JsiSkCanvas::save);
     installHostMethod(runtime, prototype, "saveLayer", &JsiSkCanvas::saveLayer);
-    installHostMethod(runtime, prototype, "restore", &JsiSkCanvas::restore);
-    installHostMethod(runtime, prototype, "rotate", &JsiSkCanvas::rotate);
-    installHostMethod(runtime, prototype, "translate", &JsiSkCanvas::translate);
-    installHostMethod(runtime, prototype, "scale", &JsiSkCanvas::scale);
-    installHostMethod(runtime, prototype, "skew", &JsiSkCanvas::skew);
-    installHostMethod(runtime, prototype, "drawColor", &JsiSkCanvas::drawColor);
-    installHostMethod(runtime, prototype, "clear", &JsiSkCanvas::clear);
-    installHostMethod(runtime, prototype, "concat", &JsiSkCanvas::concat);
-    installHostMethod(runtime, prototype, "drawPicture",
-                      &JsiSkCanvas::drawPicture);
+    installMethod(runtime, prototype, "restore", &JsiSkCanvas::restore);
+    installMethod(runtime, prototype, "rotate", &JsiSkCanvas::rotate);
+    installMethod(runtime, prototype, "translate", &JsiSkCanvas::translate);
+    installMethod(runtime, prototype, "scale", &JsiSkCanvas::scale);
+    installMethod(runtime, prototype, "skew", &JsiSkCanvas::skew);
+    installMethod(runtime, prototype, "drawColor", &JsiSkCanvas::drawColor);
+    installMethod(runtime, prototype, "clear", &JsiSkCanvas::clear);
+    installMethod(runtime, prototype, "concat", &JsiSkCanvas::concat);
+    installMethod(runtime, prototype, "drawPicture",
+                  &JsiSkCanvas::drawPicture);
     installHostMethod(runtime, prototype, "drawAtlas", &JsiSkCanvas::drawAtlas);
     installHostMethod(runtime, prototype, "readPixels",
                       &JsiSkCanvas::readPixels);

package/cpp/api/JsiSkColorFilterFactory.h

@@ -2,10 +2,12 @@
 
 #include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -24,87 +26,67 @@ class JsiSkColorFilterFactory
 public:
   static constexpr const char *CLASS_NAME = "ColorFilterFactory";
 
-  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();
-      }
+  std::shared_ptr<JsiSkColorFilter> MakeMatrix(std::vector<float> values) {
+    float matrix[20] = {0};
+    for (size_t i = 0; i < 20 && i < values.size(); i++) {
+      matrix[i] = values[i];
     }
-    // Return the newly constructed object
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Matrix(std::move(matrix))));
+    return std::make_shared<JsiSkColorFilter>(getContext(),
+                                              SkColorFilters::Matrix(matrix));
   }
 
-  JSI_HOST_FUNCTION(MakeBlend) {
-    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
-    SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
-    // Return the newly constructed object
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Blend(color, blend)));
+  std::shared_ptr<JsiSkColorFilter> MakeBlend(JsiColor color, double blend) {
+    return std::make_shared<JsiSkColorFilter>(
+        getContext(),
+        SkColorFilters::Blend(color, static_cast<SkBlendMode>(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 makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Compose(std::move(outer),
-                                                           std::move(inner))));
+  std::shared_ptr<JsiSkColorFilter> MakeCompose(sk_sp<SkColorFilter> outer,
+                                                sk_sp<SkColorFilter> inner) {
+    return 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 makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(),
-                     SkColorFilters::Lerp(t, std::move(dst), std::move(src))));
+  std::shared_ptr<JsiSkColorFilter> MakeLerp(double t,
+                                             sk_sp<SkColorFilter> dst,
+                                             sk_sp<SkColorFilter> src) {
+    return std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::Lerp(t, std::move(dst), std::move(src)));
   }
 
-  JSI_HOST_FUNCTION(MakeSRGBToLinearGamma) {
-    // Return the newly constructed object
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::SRGBToLinearGamma()));
+  std::shared_ptr<JsiSkColorFilter> MakeSRGBToLinearGamma() {
+    return std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::SRGBToLinearGamma());
   }
 
-  JSI_HOST_FUNCTION(MakeLinearToSRGBGamma) {
-    // Return the newly constructed object
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::LinearToSRGBGamma()));
+  std::shared_ptr<JsiSkColorFilter> MakeLinearToSRGBGamma() {
+    return std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::LinearToSRGBGamma());
   }
 
-  JSI_HOST_FUNCTION(MakeLumaColorFilter) {
-    // Return the newly constructed object
-    return makeJsiObject(runtime, std::make_shared<JsiSkColorFilter>(
-                                      getContext(), SkLumaColorFilter::Make()));
+  std::shared_ptr<JsiSkColorFilter> MakeLumaColorFilter() {
+    return std::make_shared<JsiSkColorFilter>(getContext(),
+                                              SkLumaColorFilter::Make());
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeMatrix",
-                      &JsiSkColorFilterFactory::MakeMatrix);
-    installHostMethod(runtime, prototype, "MakeBlend",
-                      &JsiSkColorFilterFactory::MakeBlend);
-    installHostMethod(runtime, prototype, "MakeCompose",
-                      &JsiSkColorFilterFactory::MakeCompose);
-    installHostMethod(runtime, prototype, "MakeLerp",
-                      &JsiSkColorFilterFactory::MakeLerp);
-    installHostMethod(runtime, prototype, "MakeSRGBToLinearGamma",
-                      &JsiSkColorFilterFactory::MakeSRGBToLinearGamma);
-    installHostMethod(runtime, prototype, "MakeLinearToSRGBGamma",
-                      &JsiSkColorFilterFactory::MakeLinearToSRGBGamma);
-    installHostMethod(runtime, prototype, "MakeLumaColorFilter",
-                      &JsiSkColorFilterFactory::MakeLumaColorFilter);
+    installMethod(runtime, prototype, "MakeMatrix",
+                  &JsiSkColorFilterFactory::MakeMatrix);
+    installMethod(runtime, prototype, "MakeBlend",
+                  &JsiSkColorFilterFactory::MakeBlend);
+    installMethod(runtime, prototype, "MakeCompose",
+                  &JsiSkColorFilterFactory::MakeCompose);
+    installMethod(runtime, prototype, "MakeLerp",
+                  &JsiSkColorFilterFactory::MakeLerp);
+    installMethod(runtime, prototype, "MakeSRGBToLinearGamma",
+                  &JsiSkColorFilterFactory::MakeSRGBToLinearGamma);
+    installMethod(runtime, prototype, "MakeLinearToSRGBGamma",
+                  &JsiSkColorFilterFactory::MakeLinearToSRGBGamma);
+    installMethod(runtime, prototype, "MakeLumaColorFilter",
+                  &JsiSkColorFilterFactory::MakeLumaColorFilter);
   }
 
   explicit JsiSkColorFilterFactory(std::shared_ptr<RNSkPlatformContext> context)