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

package/cpp/api/JsiSkApi.h

@@ -4,7 +4,7 @@
 
 #include "rnskia/RNSkPlatformContext.h"
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
@@ -67,11 +67,11 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkApi : public JsiSkHostObject {
+class JsiSkApi : public JsiSkNativeObject<JsiSkApi> {
 public:
-  size_t getMemoryPressure() const override { return 8192; }
+  static constexpr const char *CLASS_NAME = "Api";
 
-  std::string getObjectType() const override { return "JsiSkApi"; }
+  size_t getMemoryPressure() override { return 8192; }
 
   /**
    * Constructs the Skia Api object that can be installed into a runtime
@@ -79,104 +79,258 @@ public:
    * @param context Platform context
    */
   explicit JsiSkApi(const std::shared_ptr<RNSkPlatformContext> &context)
-      : JsiSkHostObject(context) {
+      : JsiSkNativeObject<JsiSkApi>(context),
+        _svgFactory(std::make_shared<JsiSkSVGFactory>(context)),
+        _imageFactory(std::make_shared<JsiSkImageFactory>(context)),
+        _animatedImageFactory(
+            std::make_shared<JsiSkAnimatedImageFactory>(context)),
+        _typefaceFactory(std::make_shared<JsiSkTypefaceFactory>(context)),
+        _dataFactory(std::make_shared<JsiSkDataFactory>(context)),
+        _imageFilterFactory(std::make_shared<JsiSkImageFilterFactory>(context)),
+        _pathEffectFactory(std::make_shared<JsiSkPathEffectFactory>(context)),
+        _pathFactory(std::make_shared<JsiSkPathFactory>(context)),
+        _pathBuilderFactory(std::make_shared<JsiSkPathBuilderFactory>(context)),
+        _colorFilterFactory(std::make_shared<JsiSkColorFilterFactory>(context)),
+        _maskFilterFactory(std::make_shared<JsiSkMaskFilterFactory>(context)),
+        _runtimeEffectFactory(
+            std::make_shared<JsiSkRuntimeEffectFactory>(context)),
+        _shaderFactory(std::make_shared<JsiSkShaderFactory>(context)),
+        _textBlobFactory(std::make_shared<JsiSkTextBlobFactory>(context)),
+        _surfaceFactory(std::make_shared<JsiSkSurfaceFactory>(context)),
+        _pictureFactory(std::make_shared<JsiSkPictureFactory>(context)),
+        _fontMgrFactory(std::make_shared<JsiSkFontMgrFactory>(context)),
+        _skottieFactory(std::make_shared<JsiSkottieFactory>(context)),
+        _typefaceFontProviderFactory(
+            std::make_shared<JsiSkTypefaceFontProviderFactory>(context)),
+        _paragraphBuilderFactory(
+            std::make_shared<JsiSkParagraphBuilderFactory>(context)),
+        _nativeBufferFactory(
+            std::make_shared<JsiNativeBufferFactory>(context)) {
     // We create the system font manager eagerly since it has proven to be too
     // slow to do it on demand
     JsiSkFontMgrFactory::getFontMgr(getContext());
-    installFunction("Video", JsiVideo::createCtor(context));
-    installFunction("Context", JsiSkiaContext::createCtor(context));
-    installFunction("Font", JsiSkFont::createCtor(context));
-    installFunction("Paint", JsiSkPaint::createCtor(context));
-    installFunction("RSXform", JsiSkRSXform::createCtor(context));
-    installFunction("RSXformFromRadians",
-                    JsiSkRSXform::createCtorFromRadians(context));
-    installFunction("Matrix", JsiSkMatrix::createCtor(context));
-    installFunction("XYWHRect", JsiSkRect::createCtor(context));
-    installFunction("RRectXY", JsiSkRRect::createCtor(context));
-    installFunction("Point", JsiSkPoint::createCtor(context));
-    installFunction("RuntimeShaderBuilder",
-                    JsiSkRuntimeShaderBuilder::createCtor(context));
-    installFunction("ContourMeasureIter",
-                    JsiSkContourMeasureIter::createCtor(context));
-    installFunction("MakeVertices", JsiSkVertices::createCtor(context));
-    installFunction("PictureRecorder",
-                    JsiSkPictureRecorder::createCtor(context));
-    installFunction("Color", JsiSkColor::createCtor());
-
-    installReadonlyProperty("SVG", std::make_shared<JsiSkSVGFactory>(context));
-    installReadonlyProperty("Image",
-                            std::make_shared<JsiSkImageFactory>(context));
-    installReadonlyProperty(
-        "AnimatedImage", std::make_shared<JsiSkAnimatedImageFactory>(context));
-    installReadonlyProperty("Typeface",
-                            std::make_shared<JsiSkTypefaceFactory>(context));
-    installReadonlyProperty("Data",
-                            std::make_shared<JsiSkDataFactory>(context));
-    installReadonlyProperty("ImageFilter",
-                            std::make_shared<JsiSkImageFilterFactory>(context));
-    installReadonlyProperty("PathEffect",
-                            std::make_shared<JsiSkPathEffectFactory>(context));
-    installReadonlyProperty("Path",
-                            std::make_shared<JsiSkPathFactory>(context));
-    installReadonlyProperty("PathBuilder",
-                            std::make_shared<JsiSkPathBuilderFactory>(context));
-    installReadonlyProperty("ColorFilter",
-                            std::make_shared<JsiSkColorFilterFactory>(context));
-    installReadonlyProperty("MaskFilter",
-                            std::make_shared<JsiSkMaskFilterFactory>(context));
-    installReadonlyProperty(
-        "RuntimeEffect", std::make_shared<JsiSkRuntimeEffectFactory>(context));
-    installReadonlyProperty("Shader",
-                            std::make_shared<JsiSkShaderFactory>(context));
-    installReadonlyProperty("TextBlob",
-                            std::make_shared<JsiSkTextBlobFactory>(context));
-    installReadonlyProperty("Surface",
-                            std::make_shared<JsiSkSurfaceFactory>(context));
-    installReadonlyProperty("Picture",
-                            std::make_shared<JsiSkPictureFactory>(context));
-    installReadonlyProperty("FontMgr",
-                            std::make_shared<JsiSkFontMgrFactory>(context));
-    installReadonlyProperty("Skottie",
-                            std::make_shared<JsiSkottieFactory>(context));
-    installReadonlyProperty(
-        "TypefaceFontProvider",
-        std::make_shared<JsiSkTypefaceFontProviderFactory>(context));
-
-    installReadonlyProperty(
-        "ParagraphBuilder",
-        std::make_shared<JsiSkParagraphBuilderFactory>(context));
-
-    installReadonlyProperty("NativeBuffer",
-                            std::make_shared<JsiNativeBufferFactory>(context));
-
-    installFunction("Recorder", JsiRecorder::createCtor(context));
-
-    installFunction(
-        "hasDevice", JSI_HOST_FUNCTION_LAMBDA {
+  }
+
+  // Constructor functions: each delegates to the class's createCtor host
+  // function using the platform context resolved from native state, so the
+  // prototype stays context-free and can be installed on any runtime.
+  JSI_HOST_FUNCTION(Video) {
+    return JsiVideo::createCtor(getContext())(runtime, thisValue, arguments,
+                                              count);
+  }
+  JSI_HOST_FUNCTION(Context) {
+    return JsiSkiaContext::createCtor(getContext())(runtime, thisValue,
+                                                    arguments, count);
+  }
+  JSI_HOST_FUNCTION(Font) {
+    return JsiSkFont::createCtor(getContext())(runtime, thisValue, arguments,
+                                               count);
+  }
+  JSI_HOST_FUNCTION(Paint) {
+    return JsiSkPaint::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(RSXform) {
+    return JsiSkRSXform::createCtor(getContext())(runtime, thisValue, arguments,
+                                                  count);
+  }
+  JSI_HOST_FUNCTION(RSXformFromRadians) {
+    return JsiSkRSXform::createCtorFromRadians(getContext())(runtime, thisValue,
+                                                             arguments, count);
+  }
+  JSI_HOST_FUNCTION(Matrix) {
+    return JsiSkMatrix::createCtor(getContext())(runtime, thisValue, arguments,
+                                                 count);
+  }
+  JSI_HOST_FUNCTION(XYWHRect) {
+    return JsiSkRect::createCtor(getContext())(runtime, thisValue, arguments,
+                                               count);
+  }
+  JSI_HOST_FUNCTION(RRectXY) {
+    return JsiSkRRect::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(Point) {
+    return JsiSkPoint::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(RuntimeShaderBuilder) {
+    return JsiSkRuntimeShaderBuilder::createCtor(getContext())(
+        runtime, thisValue, arguments, count);
+  }
+  JSI_HOST_FUNCTION(ContourMeasureIter) {
+    return JsiSkContourMeasureIter::createCtor(getContext())(runtime, thisValue,
+                                                             arguments, count);
+  }
+  JSI_HOST_FUNCTION(MakeVertices) {
+    return JsiSkVertices::createCtor(getContext())(runtime, thisValue,
+                                                   arguments, count);
+  }
+  JSI_HOST_FUNCTION(PictureRecorder) {
+    return JsiSkPictureRecorder::createCtor(getContext())(runtime, thisValue,
+                                                          arguments, count);
+  }
+  JSI_HOST_FUNCTION(Color) {
+    return JsiSkColor::createCtor()(runtime, thisValue, arguments, count);
+  }
+  JSI_HOST_FUNCTION(Recorder) {
+    return JsiRecorder::createCtor(getContext())(runtime, thisValue, arguments,
+                                                 count);
+  }
+
+  JSI_HOST_FUNCTION(hasDevice) {
 #ifdef SK_GRAPHITE
-          return jsi::Value(true);
+    return jsi::Value(true);
 #else
-      return jsi::Value(false);
+    return jsi::Value(false);
 #endif
-        });
+  }
 
-    installFunction(
-        "getDevice", JSI_HOST_FUNCTION_LAMBDA {
+  JSI_HOST_FUNCTION(getDevice) {
 #ifdef SK_GRAPHITE
-          auto &dawnContext = DawnContext::getInstance();
-          // Per-runtime context: async ops on this device resolve on the calling
-          // runtime's own thread (via its ProcessEvents pump).
-          auto context = rnwgpu::async::RuntimeContext::getOrCreate(
-              runtime, dawnContext.getWGPUInstance());
-          auto device = std::make_shared<rnwgpu::GPUDevice>(
-              dawnContext.getWGPUDevice(), context, "Skia Device");
-          return rnwgpu::GPUDevice::create(runtime, device);
+    auto &dawnContext = DawnContext::getInstance();
+    // Per-runtime context: async ops on this device resolve on the calling
+    // runtime's own thread (via its ProcessEvents pump).
+    auto context = rnwgpu::async::RuntimeContext::getOrCreate(
+        runtime, dawnContext.getWGPUInstance());
+    auto device = std::make_shared<rnwgpu::GPUDevice>(
+        dawnContext.getWGPUDevice(), context, "Skia Device");
+    return rnwgpu::GPUDevice::create(runtime, device);
 #else
-      throw jsi::JSError(runtime,
-                         "getDevice() is only available with the Graphite "
-                         "backend. Rebuild with SK_GRAPHITE enabled.");
+    throw jsi::JSError(runtime,
+                       "getDevice() is only available with the Graphite "
+                       "backend. Rebuild with SK_GRAPHITE enabled.");
 #endif
-        });
   }
+
+  // Factory properties: like the legacy HostObject implementation, each
+  // property access returns a fresh JS wrapper around the shared factory
+  // instance.
+  JSI_PROPERTY_GET(SVG) { return makeJsiObject(runtime, _svgFactory); }
+  JSI_PROPERTY_GET(Image) { return makeJsiObject(runtime, _imageFactory); }
+  JSI_PROPERTY_GET(AnimatedImage) {
+    return makeJsiObject(runtime, _animatedImageFactory);
+  }
+  JSI_PROPERTY_GET(Typeface) {
+    return makeJsiObject(runtime, _typefaceFactory);
+  }
+  JSI_PROPERTY_GET(Data) { return makeJsiObject(runtime, _dataFactory); }
+  JSI_PROPERTY_GET(ImageFilter) {
+    return makeJsiObject(runtime, _imageFilterFactory);
+  }
+  JSI_PROPERTY_GET(PathEffect) {
+    return makeJsiObject(runtime, _pathEffectFactory);
+  }
+  JSI_PROPERTY_GET(Path) { return makeJsiObject(runtime, _pathFactory); }
+  JSI_PROPERTY_GET(PathBuilder) {
+    return makeJsiObject(runtime, _pathBuilderFactory);
+  }
+  JSI_PROPERTY_GET(ColorFilter) {
+    return makeJsiObject(runtime, _colorFilterFactory);
+  }
+  JSI_PROPERTY_GET(MaskFilter) {
+    return makeJsiObject(runtime, _maskFilterFactory);
+  }
+  JSI_PROPERTY_GET(RuntimeEffect) {
+    return makeJsiObject(runtime, _runtimeEffectFactory);
+  }
+  JSI_PROPERTY_GET(Shader) { return makeJsiObject(runtime, _shaderFactory); }
+  JSI_PROPERTY_GET(TextBlob) {
+    return makeJsiObject(runtime, _textBlobFactory);
+  }
+  JSI_PROPERTY_GET(Surface) { return makeJsiObject(runtime, _surfaceFactory); }
+  JSI_PROPERTY_GET(Picture) { return makeJsiObject(runtime, _pictureFactory); }
+  JSI_PROPERTY_GET(FontMgr) { return makeJsiObject(runtime, _fontMgrFactory); }
+  JSI_PROPERTY_GET(Skottie) { return makeJsiObject(runtime, _skottieFactory); }
+  JSI_PROPERTY_GET(TypefaceFontProvider) {
+    return makeJsiObject(runtime, _typefaceFontProviderFactory);
+  }
+  JSI_PROPERTY_GET(ParagraphBuilder) {
+    return makeJsiObject(runtime, _paragraphBuilderFactory);
+  }
+  JSI_PROPERTY_GET(NativeBuffer) {
+    return makeJsiObject(runtime, _nativeBufferFactory);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Video", &JsiSkApi::Video);
+    installHostMethod(runtime, prototype, "Context", &JsiSkApi::Context);
+    installHostMethod(runtime, prototype, "Font", &JsiSkApi::Font);
+    installHostMethod(runtime, prototype, "Paint", &JsiSkApi::Paint);
+    installHostMethod(runtime, prototype, "RSXform", &JsiSkApi::RSXform);
+    installHostMethod(runtime, prototype, "RSXformFromRadians",
+                      &JsiSkApi::RSXformFromRadians);
+    installHostMethod(runtime, prototype, "Matrix", &JsiSkApi::Matrix);
+    installHostMethod(runtime, prototype, "XYWHRect", &JsiSkApi::XYWHRect);
+    installHostMethod(runtime, prototype, "RRectXY", &JsiSkApi::RRectXY);
+    installHostMethod(runtime, prototype, "Point", &JsiSkApi::Point);
+    installHostMethod(runtime, prototype, "RuntimeShaderBuilder",
+                      &JsiSkApi::RuntimeShaderBuilder);
+    installHostMethod(runtime, prototype, "ContourMeasureIter",
+                      &JsiSkApi::ContourMeasureIter);
+    installHostMethod(runtime, prototype, "MakeVertices",
+                      &JsiSkApi::MakeVertices);
+    installHostMethod(runtime, prototype, "PictureRecorder",
+                      &JsiSkApi::PictureRecorder);
+    installHostMethod(runtime, prototype, "Color", &JsiSkApi::Color);
+    installHostMethod(runtime, prototype, "Recorder", &JsiSkApi::Recorder);
+    installHostMethod(runtime, prototype, "hasDevice", &JsiSkApi::hasDevice);
+    installHostMethod(runtime, prototype, "getDevice", &JsiSkApi::getDevice);
+    installHostGetter(runtime, prototype, "SVG", &JsiSkApi::get_SVG);
+    installHostGetter(runtime, prototype, "Image", &JsiSkApi::get_Image);
+    installHostGetter(runtime, prototype, "AnimatedImage",
+                      &JsiSkApi::get_AnimatedImage);
+    installHostGetter(runtime, prototype, "Typeface", &JsiSkApi::get_Typeface);
+    installHostGetter(runtime, prototype, "Data", &JsiSkApi::get_Data);
+    installHostGetter(runtime, prototype, "ImageFilter",
+                      &JsiSkApi::get_ImageFilter);
+    installHostGetter(runtime, prototype, "PathEffect",
+                      &JsiSkApi::get_PathEffect);
+    installHostGetter(runtime, prototype, "Path", &JsiSkApi::get_Path);
+    installHostGetter(runtime, prototype, "PathBuilder",
+                      &JsiSkApi::get_PathBuilder);
+    installHostGetter(runtime, prototype, "ColorFilter",
+                      &JsiSkApi::get_ColorFilter);
+    installHostGetter(runtime, prototype, "MaskFilter",
+                      &JsiSkApi::get_MaskFilter);
+    installHostGetter(runtime, prototype, "RuntimeEffect",
+                      &JsiSkApi::get_RuntimeEffect);
+    installHostGetter(runtime, prototype, "Shader", &JsiSkApi::get_Shader);
+    installHostGetter(runtime, prototype, "TextBlob", &JsiSkApi::get_TextBlob);
+    installHostGetter(runtime, prototype, "Surface", &JsiSkApi::get_Surface);
+    installHostGetter(runtime, prototype, "Picture", &JsiSkApi::get_Picture);
+    installHostGetter(runtime, prototype, "FontMgr", &JsiSkApi::get_FontMgr);
+    installHostGetter(runtime, prototype, "Skottie", &JsiSkApi::get_Skottie);
+    installHostGetter(runtime, prototype, "TypefaceFontProvider",
+                      &JsiSkApi::get_TypefaceFontProvider);
+    installHostGetter(runtime, prototype, "ParagraphBuilder",
+                      &JsiSkApi::get_ParagraphBuilder);
+    installHostGetter(runtime, prototype, "NativeBuffer",
+                      &JsiSkApi::get_NativeBuffer);
+  }
+
+private:
+  std::shared_ptr<JsiSkSVGFactory> _svgFactory;
+  std::shared_ptr<JsiSkImageFactory> _imageFactory;
+  std::shared_ptr<JsiSkAnimatedImageFactory> _animatedImageFactory;
+  std::shared_ptr<JsiSkTypefaceFactory> _typefaceFactory;
+  std::shared_ptr<JsiSkDataFactory> _dataFactory;
+  std::shared_ptr<JsiSkImageFilterFactory> _imageFilterFactory;
+  std::shared_ptr<JsiSkPathEffectFactory> _pathEffectFactory;
+  std::shared_ptr<JsiSkPathFactory> _pathFactory;
+  std::shared_ptr<JsiSkPathBuilderFactory> _pathBuilderFactory;
+  std::shared_ptr<JsiSkColorFilterFactory> _colorFilterFactory;
+  std::shared_ptr<JsiSkMaskFilterFactory> _maskFilterFactory;
+  std::shared_ptr<JsiSkRuntimeEffectFactory> _runtimeEffectFactory;
+  std::shared_ptr<JsiSkShaderFactory> _shaderFactory;
+  std::shared_ptr<JsiSkTextBlobFactory> _textBlobFactory;
+  std::shared_ptr<JsiSkSurfaceFactory> _surfaceFactory;
+  std::shared_ptr<JsiSkPictureFactory> _pictureFactory;
+  std::shared_ptr<JsiSkFontMgrFactory> _fontMgrFactory;
+  std::shared_ptr<JsiSkottieFactory> _skottieFactory;
+  std::shared_ptr<JsiSkTypefaceFontProviderFactory>
+      _typefaceFontProviderFactory;
+  std::shared_ptr<JsiSkParagraphBuilderFactory> _paragraphBuilderFactory;
+  std::shared_ptr<JsiNativeBufferFactory> _nativeBufferFactory;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkCanvas.h

@@ -5,10 +5,10 @@
 #include <vector>
 
 #include "JsiSkFont.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPaint.h"
 #include "JsiSkPath.h"
 #include "JsiSkPicture.h"
@@ -49,8 +49,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkCanvas : public JsiSkHostObject {
+class JsiSkCanvas : public JsiSkNativeObject<JsiSkCanvas> {
 public:
+  static constexpr const char *CLASS_NAME = "Canvas";
+
   JSI_HOST_FUNCTION(drawPaint) {
     auto paint = JsiSkPaint::fromValue(runtime, arguments[0]);
     _canvas->drawPaint(*paint);
@@ -246,10 +248,8 @@ public:
   }
 
   JSI_HOST_FUNCTION(getTotalMatrix) {
-    auto matrix =
-        std::make_shared<JsiSkMatrix>(getContext(), _canvas->getTotalMatrix());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, matrix,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkMatrix>(
+                                      getContext(), _canvas->getTotalMatrix()));
   }
 
   JSI_HOST_FUNCTION(drawPoints) {
@@ -651,9 +651,10 @@ public:
 #if defined(SK_GRAPHITE)
     // Graphite records draws lazily and offers no synchronous GPU readback. If
     // this canvas belongs to a surface, snap & submit its recording, snapshot
-    // it to a CPU raster image and read from that (mirroring makeImageSnapshot).
-    // A canvas without an owning surface (e.g. a picture-recording canvas) has
-    // no texture to read back, so fall through to the raster canvas read below.
+    // it to a CPU raster image and read from that (mirroring
+    // makeImageSnapshot). A canvas without an owning surface (e.g. a
+    // picture-recording canvas) has no texture to read back, so fall through to
+    // the raster canvas read below.
     if (_surface) {
       // Snapshot first: makeImageSnapshot records a copy task into the recorder
       // that must be submitted before the texture can be read back (this is the
@@ -663,8 +664,8 @@ public:
         DawnContext::getInstance().submitRecording(recorder->snap().get());
       }
       auto raster = DawnContext::getInstance().MakeRasterImage(snapshot);
-      if (!raster ||
-          !raster->readPixels(nullptr, *info, bfrPtr, bytesPerRow, srcX, srcY)) {
+      if (!raster || !raster->readPixels(nullptr, *info, bfrPtr, bytesPerRow,
+                                         srcX, srcY)) {
         return jsi::Value::null();
       }
       return dest;
@@ -677,55 +678,72 @@ public:
     return dest;
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkCanvas, drawPaint),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawLine),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImage),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageCubic),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageOptions),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageNine),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageRectCubic),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawImageRectOptions),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawCircle),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawArc),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawRRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawDRRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawOval),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, restoreToCount),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, getSaveCount),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, getTotalMatrix),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawPoints),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawPatch),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawPath),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawVertices),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawText),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawTextBlob),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawGlyphs),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawSvg),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, clipPath),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, clipRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, clipRRect),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, save),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, saveLayer),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, restore),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, rotate),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, translate),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, scale),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, skew),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawColor),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, clear),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, concat),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawPicture),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, drawAtlas),
-                       JSI_EXPORT_FUNC(JsiSkCanvas, readPixels))
-
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkCanvas"; }
+  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);
+    installHostMethod(runtime, prototype, "drawImage", &JsiSkCanvas::drawImage);
+    installHostMethod(runtime, prototype, "drawImageRect",
+                      &JsiSkCanvas::drawImageRect);
+    installHostMethod(runtime, prototype, "drawImageCubic",
+                      &JsiSkCanvas::drawImageCubic);
+    installHostMethod(runtime, prototype, "drawImageOptions",
+                      &JsiSkCanvas::drawImageOptions);
+    installHostMethod(runtime, prototype, "drawImageNine",
+                      &JsiSkCanvas::drawImageNine);
+    installHostMethod(runtime, prototype, "drawImageRectCubic",
+                      &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);
+    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);
+    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);
+    installHostMethod(runtime, prototype, "drawAtlas", &JsiSkCanvas::drawAtlas);
+    installHostMethod(runtime, prototype, "readPixels",
+                      &JsiSkCanvas::readPixels);
+  }
+
+  size_t getMemoryPressure() override { return 1024; }
 
   explicit JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkCanvas>(std::move(context)) {}
 
   JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context, SkCanvas *canvas)
       : JsiSkCanvas(std::move(context)) {

package/cpp/api/JsiSkColor.h

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "api/third_party/CSSColorParser.h"
 
 #pragma clang diagnostic push
@@ -20,11 +20,13 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkColor : public RNJsi::JsiHostObject {
+/**
+ * JsiSkColor is a pure utility class — colors are represented as
+ * Float32Arrays on the JS side, so there is no wrapper object.
+ */
+class JsiSkColor {
 public:
-  JsiSkColor() : JsiHostObject() {}
-
-  ~JsiSkColor() override = default;
+  JsiSkColor() = default;
 
   static jsi::Object toValue(jsi::Runtime &runtime, SkColor color) {
     auto result = runtime.global()

package/cpp/api/JsiSkColorFilter.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
@@ -16,19 +16,26 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkColorFilter : public JsiSkWrappingSkPtrHostObject<SkColorFilter> {
+class JsiSkColorFilter
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkColorFilter, SkColorFilter> {
 public:
+  static constexpr const char *CLASS_NAME = "ColorFilter";
+
   JsiSkColorFilter(std::shared_ptr<RNSkPlatformContext> context,
                    sk_sp<SkColorFilter> colorFilter)
-      : JsiSkWrappingSkPtrHostObject<SkColorFilter>(std::move(context),
-                                                    std::move(colorFilter)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkColorFilter, SkColorFilter>(
+            std::move(context), std::move(colorFilter)) {}
 
-  size_t getMemoryPressure() const override { return 2048; }
+  size_t getMemoryPressure() override { return 2048; }
 
-  std::string getObjectType() const override { return "JsiSkColorFilter"; }
+  static sk_sp<SkColorFilter> fromValue(jsi::Runtime &runtime,
+                                        const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkColorFilter, ColorFilter)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkColorFilter, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 };
 
 } // namespace RNSkia