@shopify/react-native-skia 2.10.0 → 2.10.1

package/cpp/api/JsiSkPicture.h

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
 #include "JsiSkDispatcher.h"
 #include "JsiSkMatrix.h"
@@ -56,22 +58,15 @@ public:
     }
   }
 
-  JSI_HOST_FUNCTION(makeShader) {
-    auto tmx = (SkTileMode)arguments[0].asNumber();
-    auto tmy = (SkTileMode)arguments[1].asNumber();
-    auto fm = (SkFilterMode)arguments[2].asNumber();
-    auto m = count > 3 && !arguments[3].isUndefined()
-                 ? JsiSkMatrix::fromValue(runtime, arguments[3]).get()
-                 : nullptr;
-
-    auto tr = count > 4 && !arguments[4].isUndefined()
-                  ? JsiSkRect::fromValue(runtime, arguments[4]).get()
-                  : nullptr;
-
-    // Create shader
-    auto shader = getObject()->makeShader(tmx, tmy, fm, m, tr);
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkShader>(getContext(), shader));
+  std::shared_ptr<JsiSkShader>
+  makeShader(double tmx, double tmy, double fm,
+             std::optional<std::shared_ptr<SkMatrix>> m,
+             std::optional<std::shared_ptr<SkRect>> tr) {
+    auto shader = getObject()->makeShader(
+        static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
+        static_cast<SkFilterMode>(fm), m.has_value() ? m->get() : nullptr,
+        tr.has_value() ? tr->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), shader);
   }
 
   JSI_HOST_FUNCTION(serialize) {
@@ -103,8 +98,7 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "makeShader",
-                      &JsiSkPicture::makeShader);
+    installMethod(runtime, prototype, "makeShader", &JsiSkPicture::makeShader);
     installHostMethod(runtime, prototype, "serialize",
                       &JsiSkPicture::serialize);
   }

package/cpp/api/JsiSkPictureRecorder.h

@@ -3,6 +3,7 @@
 #include <memory>
 
 #include "JsiSkCanvas.h"
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkPicture.h"
 #include "JsiSkRect.h"
@@ -30,33 +31,31 @@ public:
                                            SkPictureRecorder>(
             context, std::make_shared<SkPictureRecorder>()) {}
 
-  JSI_HOST_FUNCTION(beginRecording) {
+  std::shared_ptr<JsiSkCanvas>
+  beginRecording(JsiOptional<std::shared_ptr<SkRect>> rect) {
     SkCanvas *canvas;
-    if (count > 0 && !arguments[0].isUndefined()) {
-      auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+    if (rect.has_value()) {
       SkRTreeFactory factory;
-      canvas = getObject()->beginRecording(*rect, &factory);
+      canvas = getObject()->beginRecording(**rect, &factory);
     } else {
       SkISize size = SkISize::Make(2'000'000, 2'000'000);
-      SkRect rect = SkRect::Make(size);
-      canvas = getObject()->beginRecording(rect, nullptr);
+      SkRect bounds = SkRect::Make(size);
+      canvas = getObject()->beginRecording(bounds, nullptr);
     }
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkCanvas>(getContext(), canvas));
+    return std::make_shared<JsiSkCanvas>(getContext(), canvas);
   }
 
-  JSI_HOST_FUNCTION(finishRecordingAsPicture) {
+  std::shared_ptr<JsiSkPicture> finishRecordingAsPicture() {
     auto picture = getObject()->finishRecordingAsPicture();
-    return makeJsiObject(runtime, std::make_shared<JsiSkPicture>(
-                                      getContext(), std::move(picture)));
+    return std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "beginRecording",
-                      &JsiSkPictureRecorder::beginRecording);
-    installHostMethod(runtime, prototype, "finishRecordingAsPicture",
-                      &JsiSkPictureRecorder::finishRecordingAsPicture);
+    installMethod(runtime, prototype, "beginRecording",
+                  &JsiSkPictureRecorder::beginRecording);
+    installMethod(runtime, prototype, "finishRecordingAsPicture",
+                  &JsiSkPictureRecorder::finishRecordingAsPicture);
   }
 
   size_t getMemoryPressure() override { return 1024 * 1024; }

package/cpp/api/JsiSkPoint.h

@@ -23,14 +23,14 @@ class JsiSkPoint
 public:
   static constexpr const char *CLASS_NAME = "Point";
 
-  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
+  double getX() { return static_cast<double>(getObject()->x()); }
 
-  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
+  double getY() { return static_cast<double>(getObject()->y()); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostGetter(runtime, prototype, "x", &JsiSkPoint::get_x);
-    installHostGetter(runtime, prototype, "y", &JsiSkPoint::get_y);
+    installGetter(runtime, prototype, "x", &JsiSkPoint::getX);
+    installGetter(runtime, prototype, "y", &JsiSkPoint::getY);
   }
 
   JsiSkPoint(std::shared_ptr<RNSkPlatformContext> context, const SkPoint &point)

package/cpp/api/JsiSkRRect.h

@@ -26,22 +26,21 @@ class JsiSkRRect
 public:
   static constexpr const char *CLASS_NAME = "RRect";
 
-  JSI_PROPERTY_GET(rx) {
+  double getRx() {
     return static_cast<double>(getObject()->getSimpleRadii().x());
   }
-  JSI_PROPERTY_GET(ry) {
+  double getRy() {
     return static_cast<double>(getObject()->getSimpleRadii().y());
   }
-  JSI_PROPERTY_GET(rect) {
-    return makeJsiObject(runtime, std::make_shared<JsiSkRect>(
-                                      getContext(), getObject()->getBounds()));
+  std::shared_ptr<JsiSkRect> getRect() {
+    return std::make_shared<JsiSkRect>(getContext(), getObject()->getBounds());
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostGetter(runtime, prototype, "rx", &JsiSkRRect::get_rx);
-    installHostGetter(runtime, prototype, "ry", &JsiSkRRect::get_ry);
-    installHostGetter(runtime, prototype, "rect", &JsiSkRRect::get_rect);
+    installGetter(runtime, prototype, "rx", &JsiSkRRect::getRx);
+    installGetter(runtime, prototype, "ry", &JsiSkRRect::getRy);
+    installGetter(runtime, prototype, "rect", &JsiSkRRect::getRect);
   }
 
   JsiSkRRect(std::shared_ptr<RNSkPlatformContext> context, const SkRRect &rect)

package/cpp/api/JsiSkRSXform.h

@@ -28,38 +28,25 @@ public:
       : JsiSkWrappingSharedPtrNativeObject<JsiSkRSXform, SkRSXform>(
             std::move(context), std::make_shared<SkRSXform>(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));
-  }
+  double getScos() { return SkScalarToDouble(getObject()->fSCos); }
+  double getSsin() { return SkScalarToDouble(getObject()->fSSin); }
+  double getTx() { return SkScalarToDouble(getObject()->fTx); }
+  double getTy() { return SkScalarToDouble(getObject()->fTy); }
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Woverloaded-virtual"
-  JSI_HOST_FUNCTION(set) {
-    auto scos = arguments[0].asNumber();
-    auto ssin = arguments[1].asNumber();
-    auto tx = arguments[2].asNumber();
-    auto ty = arguments[3].asNumber();
+  void set(double scos, double ssin, double tx, double ty) {
     getObject()->set(scos, ssin, tx, ty);
-    return jsi::Value::undefined();
   }
 #pragma clang diagnostic pop
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostGetter(runtime, prototype, "scos", &JsiSkRSXform::get_scos);
-    installHostGetter(runtime, prototype, "ssin", &JsiSkRSXform::get_ssin);
-    installHostGetter(runtime, prototype, "tx", &JsiSkRSXform::get_tx);
-    installHostGetter(runtime, prototype, "ty", &JsiSkRSXform::get_ty);
-    installHostMethod(runtime, prototype, "set", &JsiSkRSXform::set);
+    installGetter(runtime, prototype, "scos", &JsiSkRSXform::getScos);
+    installGetter(runtime, prototype, "ssin", &JsiSkRSXform::getSsin);
+    installGetter(runtime, prototype, "tx", &JsiSkRSXform::getTx);
+    installGetter(runtime, prototype, "ty", &JsiSkRSXform::getTy);
+    installMethod(runtime, prototype, "set", &JsiSkRSXform::set);
   }
 
   /**

package/cpp/api/JsiSkRect.h

@@ -22,43 +22,35 @@ class JsiSkRect : public JsiSkWrappingSharedPtrNativeObject<JsiSkRect, SkRect> {
 public:
   static constexpr const char *CLASS_NAME = "Rect";
 
-  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_HOST_FUNCTION(setXYWH) {
-    getObject()->setXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
-                         arguments[2].asNumber(), arguments[3].asNumber());
-    return jsi::Value::undefined();
+  double getX() { return static_cast<double>(getObject()->x()); }
+  double getY() { return static_cast<double>(getObject()->y()); }
+  double getWidth() { return static_cast<double>(getObject()->width()); }
+  double getHeight() { return static_cast<double>(getObject()->height()); }
+  double getLeft() { return static_cast<double>(getObject()->left()); }
+  double getTop() { return static_cast<double>(getObject()->top()); }
+  double getRight() { return static_cast<double>(getObject()->right()); }
+  double getBottom() { return static_cast<double>(getObject()->bottom()); }
+
+  void setXYWH(double x, double y, double width, double height) {
+    getObject()->setXYWH(x, y, width, height);
   }
 
-  JSI_HOST_FUNCTION(setLTRB) {
-    getObject()->setLTRB(arguments[0].asNumber(), arguments[1].asNumber(),
-                         arguments[2].asNumber(), arguments[3].asNumber());
-    return jsi::Value::undefined();
+  void setLTRB(double left, double top, double right, double bottom) {
+    getObject()->setLTRB(left, top, right, bottom);
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostGetter(runtime, prototype, "x", &JsiSkRect::get_x);
-    installHostGetter(runtime, prototype, "y", &JsiSkRect::get_y);
-    installHostGetter(runtime, prototype, "width", &JsiSkRect::get_width);
-    installHostGetter(runtime, prototype, "height", &JsiSkRect::get_height);
-    installHostGetter(runtime, prototype, "left", &JsiSkRect::get_left);
-    installHostGetter(runtime, prototype, "top", &JsiSkRect::get_top);
-    installHostGetter(runtime, prototype, "right", &JsiSkRect::get_right);
-    installHostGetter(runtime, prototype, "bottom", &JsiSkRect::get_bottom);
-    installHostMethod(runtime, prototype, "setXYWH", &JsiSkRect::setXYWH);
-    installHostMethod(runtime, prototype, "setLTRB", &JsiSkRect::setLTRB);
+    installGetter(runtime, prototype, "x", &JsiSkRect::getX);
+    installGetter(runtime, prototype, "y", &JsiSkRect::getY);
+    installGetter(runtime, prototype, "width", &JsiSkRect::getWidth);
+    installGetter(runtime, prototype, "height", &JsiSkRect::getHeight);
+    installGetter(runtime, prototype, "left", &JsiSkRect::getLeft);
+    installGetter(runtime, prototype, "top", &JsiSkRect::getTop);
+    installGetter(runtime, prototype, "right", &JsiSkRect::getRight);
+    installGetter(runtime, prototype, "bottom", &JsiSkRect::getBottom);
+    installMethod(runtime, prototype, "setXYWH", &JsiSkRect::setXYWH);
+    installMethod(runtime, prototype, "setLTRB", &JsiSkRect::setLTRB);
   }
 
   /**

package/cpp/api/JsiSkRuntimeEffect.h

@@ -5,6 +5,7 @@
 #include <utility>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkShader.h"
@@ -36,108 +37,95 @@ struct RuntimeEffectUniform {
   bool isInteger;
 };
 
+} // namespace RNSkia
+
+namespace rnwgpu {
+
+// RuntimeEffectUniform -> {columns, rows, slot, isInteger}
+template <> struct JSIConverter<RNSkia::RuntimeEffectUniform> {
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          const RNSkia::RuntimeEffectUniform &u) {
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "columns", u.columns);
+    result.setProperty(runtime, "rows", u.rows);
+    result.setProperty(runtime, "slot", u.slot);
+    result.setProperty(runtime, "isInteger", u.isInteger);
+    return result;
+  }
+};
+
+} // namespace rnwgpu
+
+namespace RNSkia {
+
 class JsiSkRuntimeEffect
     : public JsiSkWrappingSkPtrNativeObject<JsiSkRuntimeEffect,
                                             SkRuntimeEffect> {
 public:
   static constexpr const char *CLASS_NAME = "RuntimeEffect";
 
-  JSI_HOST_FUNCTION(makeShader) {
-    auto uniforms = castUniforms(runtime, arguments[0]);
-
-    auto matrix =
-        count >= 2 && !arguments[1].isUndefined() && !arguments[1].isNull()
-            ? JsiSkMatrix::fromValue(runtime, arguments[1]).get()
-            : nullptr;
-
-    // Create and return shader as host object
-    auto shader =
-        getObject()->makeShader(std::move(uniforms), nullptr, 0, matrix);
-
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(shader)));
+  std::shared_ptr<JsiSkShader>
+  makeShader(std::vector<double> uniformValues,
+             JsiOptional<std::shared_ptr<SkMatrix>> matrix) {
+    auto uniforms = castUniforms(uniformValues);
+    auto shader = getObject()->makeShader(
+        std::move(uniforms), nullptr, 0,
+        matrix.has_value() ? matrix->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
   }
 
-  JSI_HOST_FUNCTION(makeShaderWithChildren) {
-    auto uniforms = castUniforms(runtime, arguments[0]);
-
-    // Children
-    std::vector<sk_sp<SkShader>> children;
-    auto jsiChildren = arguments[1].asObject(runtime).asArray(runtime);
-    auto jsiChildCount = jsiChildren.size(runtime);
-    children.reserve(jsiChildCount);
-    for (int i = 0; i < jsiChildCount; i++) {
-      auto shader = getJsiObject<JsiSkShader>(
-                        runtime, jsiChildren.getValueAtIndex(runtime, i))
-                        ->getObject();
-      children.push_back(shader);
-    }
-
-    auto matrix =
-        count >= 3 && !arguments[2].isUndefined() && !arguments[2].isNull()
-            ? JsiSkMatrix::fromValue(runtime, arguments[2]).get()
-            : nullptr;
-
-    // Create and return shader as host object
-    auto shader = getObject()->makeShader(std::move(uniforms), children.data(),
-                                          children.size(), matrix);
-
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(shader)));
+  std::shared_ptr<JsiSkShader>
+  makeShaderWithChildren(std::vector<double> uniformValues,
+                         std::vector<sk_sp<SkShader>> children,
+                         JsiOptional<std::shared_ptr<SkMatrix>> matrix) {
+    auto uniforms = castUniforms(uniformValues);
+    auto shader = getObject()->makeShader(
+        std::move(uniforms), children.data(), children.size(),
+        matrix.has_value() ? matrix->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
   }
 
-  JSI_HOST_FUNCTION(getUniformCount) {
+  int getUniformCount() {
     return static_cast<int>(getObject()->uniforms().size());
   }
 
-  JSI_HOST_FUNCTION(getUniformFloatCount) {
+  int getUniformFloatCount() {
     return static_cast<int>(getObject()->uniformSize() / sizeof(float));
   }
 
-  JSI_HOST_FUNCTION(getUniformName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getUniformName(int i) {
     if (i < 0 || i >= getObject()->uniforms().size()) {
-      throw jsi::JSError(runtime, "invalid uniform index");
+      throw std::runtime_error("invalid uniform index");
     }
     auto it = getObject()->uniforms().begin() + i;
-    return jsi::String::createFromAscii(runtime, std::string(it->name));
+    return std::string(it->name);
   }
 
-  JSI_HOST_FUNCTION(getUniform) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  RuntimeEffectUniform getUniform(int i) {
     if (i < 0 || i >= getObject()->uniforms().size()) {
-      throw jsi::JSError(runtime, "invalid uniform index");
+      throw std::runtime_error("invalid uniform index");
     }
     auto it = getObject()->uniforms().begin() + i;
-    auto result = jsi::Object(runtime);
-    RuntimeEffectUniform su = fromUniform(*it);
-    result.setProperty(runtime, "columns", su.columns);
-    result.setProperty(runtime, "rows", su.rows);
-    result.setProperty(runtime, "slot", su.slot);
-    result.setProperty(runtime, "isInteger", su.isInteger);
-    return result;
+    return fromUniform(*it);
   }
 
-  JSI_HOST_FUNCTION(source) {
-    return jsi::String::createFromAscii(runtime, getObject()->source());
-  }
+  std::string source() { return std::string(getObject()->source()); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "makeShader",
-                      &JsiSkRuntimeEffect::makeShader);
-    installHostMethod(runtime, prototype, "makeShaderWithChildren",
-                      &JsiSkRuntimeEffect::makeShaderWithChildren);
-    installHostMethod(runtime, prototype, "getUniformCount",
-                      &JsiSkRuntimeEffect::getUniformCount);
-    installHostMethod(runtime, prototype, "getUniformFloatCount",
-                      &JsiSkRuntimeEffect::getUniformFloatCount);
-    installHostMethod(runtime, prototype, "getUniformName",
-                      &JsiSkRuntimeEffect::getUniformName);
-    installHostMethod(runtime, prototype, "getUniform",
-                      &JsiSkRuntimeEffect::getUniform);
-    installHostMethod(runtime, prototype, "source",
-                      &JsiSkRuntimeEffect::source);
+    installMethod(runtime, prototype, "makeShader",
+                  &JsiSkRuntimeEffect::makeShader);
+    installMethod(runtime, prototype, "makeShaderWithChildren",
+                  &JsiSkRuntimeEffect::makeShaderWithChildren);
+    installMethod(runtime, prototype, "getUniformCount",
+                  &JsiSkRuntimeEffect::getUniformCount);
+    installMethod(runtime, prototype, "getUniformFloatCount",
+                  &JsiSkRuntimeEffect::getUniformFloatCount);
+    installMethod(runtime, prototype, "getUniformName",
+                  &JsiSkRuntimeEffect::getUniformName);
+    installMethod(runtime, prototype, "getUniform",
+                  &JsiSkRuntimeEffect::getUniform);
+    installMethod(runtime, prototype, "source", &JsiSkRuntimeEffect::source);
   }
 
   JsiSkRuntimeEffect(std::shared_ptr<RNSkPlatformContext> context,
@@ -206,17 +194,13 @@ public:
   }
 
 private:
-  sk_sp<SkData> castUniforms(jsi::Runtime &runtime, const jsi::Value &value) {
-    auto jsiUniforms = value.asObject(runtime).asArray(runtime);
-    auto jsiUniformsSize = jsiUniforms.size(runtime);
-
+  sk_sp<SkData> castUniforms(const std::vector<double> &values) {
     // verify size of input uniforms
-    if (jsiUniformsSize * sizeof(float) != getObject()->uniformSize()) {
-      std::string msg =
+    if (values.size() * sizeof(float) != getObject()->uniformSize()) {
+      throw std::runtime_error(
           "Uniforms size differs from effect's uniform size. Received " +
-          std::to_string(jsiUniformsSize) + " expected " +
-          std::to_string(getObject()->uniformSize() / sizeof(float));
-      throw jsi::JSError(runtime, msg.c_str());
+          std::to_string(values.size()) + " expected " +
+          std::to_string(getObject()->uniformSize() / sizeof(float)));
     }
 
     auto uniforms = SkData::MakeUninitialized(getObject()->uniformSize());
@@ -228,7 +212,7 @@ private:
       RuntimeEffectUniform reu = fromUniform(*it);
       for (std::size_t j = 0; j < reu.columns * reu.rows; ++j) {
         const std::size_t offset = reu.slot + j;
-        float fValue = jsiUniforms.getValueAtIndex(runtime, offset).asNumber();
+        float fValue = static_cast<float>(values[offset]);
         int iValue = static_cast<int>(fValue);
         auto value = reu.isInteger ? SkBits2Float(iValue) : fValue;
         memcpy(SkTAddOffset<void>(uniforms->writable_data(),

package/cpp/api/JsiSkRuntimeEffectFactory.h

@@ -18,26 +18,22 @@ class JsiSkRuntimeEffectFactory
 public:
   static constexpr const char *CLASS_NAME = "RuntimeEffectFactory";
 
-  JSI_HOST_FUNCTION(Make) {
-    auto sksl = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkRuntimeEffect> Make(std::string sksl) {
     auto result = SkRuntimeEffect::MakeForShader(SkString(sksl));
     auto effect = result.effect;
     auto errorText = result.errorText;
     if (!effect) {
-      throw jsi::JSError(runtime, std::string("Error in sksl:\n" +
-                                              std::string(errorText.c_str()))
-                                      .c_str());
-      return jsi::Value::null();
+      throw std::runtime_error("Error in sksl:\n" +
+                               std::string(errorText.c_str()));
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkRuntimeEffect>(
-                                      getContext(), std::move(effect)));
+    return std::make_shared<JsiSkRuntimeEffect>(getContext(),
+                                                std::move(effect));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Make",
-                      &JsiSkRuntimeEffectFactory::Make);
+    installMethod(runtime, prototype, "Make", &JsiSkRuntimeEffectFactory::Make);
   }
 
   explicit JsiSkRuntimeEffectFactory(

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -35,26 +36,16 @@ public:
                                            SkRuntimeShaderBuilder>(
             std::move(context), std::make_shared<SkRuntimeShaderBuilder>(rt)) {}
 
-  JSI_HOST_FUNCTION(setUniform) {
-    auto name = arguments[0].asString(runtime).utf8(runtime);
-    auto jsiValue = arguments[1].asObject(runtime).asArray(runtime);
-    auto size = jsiValue.size(runtime);
-    std::vector<SkScalar> value;
-    value.reserve(size);
-    for (int i = 0; i < size; i++) {
-      auto e = jsiValue.getValueAtIndex(runtime, i).asNumber();
-      value.push_back(e);
-    }
+  void setUniform(std::string name, std::vector<float> value) {
     getObject()
         ->uniform(name.c_str())
-        .set(value.data(), static_cast<int>(size));
-    return jsi::Value::undefined();
+        .set(value.data(), static_cast<int>(value.size()));
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "setUniform",
-                      &JsiSkRuntimeShaderBuilder::setUniform);
+    installMethod(runtime, prototype, "setUniform",
+                  &JsiSkRuntimeShaderBuilder::setUniform);
   }
 
   /**

package/cpp/api/JsiSkSVG.h

@@ -29,18 +29,18 @@ public:
 
   ~JsiSkSVG() = default;
 
-  JSI_HOST_FUNCTION(width) {
+  double width() {
     return static_cast<double>(getObject()->containerSize().width());
   }
 
-  JSI_HOST_FUNCTION(height) {
+  double height() {
     return static_cast<double>(getObject()->containerSize().height());
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "width", &JsiSkSVG::width);
-    installHostMethod(runtime, prototype, "height", &JsiSkSVG::height);
+    installMethod(runtime, prototype, "width", &JsiSkSVG::width);
+    installMethod(runtime, prototype, "height", &JsiSkSVG::height);
   }
 
   /**