@shopify/react-native-skia 2.13.1 → 2.14.0

package/cpp/api/JsiSkPath.h

@@ -3,7 +3,6 @@
 #include <algorithm>
 #include <memory>
 #include <optional>
-#include <set>
 #include <string>
 #include <utility>
 #include <variant>
@@ -41,29 +40,6 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-// Track which deprecation warnings have been shown to avoid spam
-inline std::set<std::string> &getShownPathDeprecationWarnings() {
-  static std::set<std::string> warnings;
-  return warnings;
-}
-
-inline void warnDeprecatedPathMethod(jsi::Runtime &runtime,
-                                     const char *methodName,
-                                     const char *suggestion) {
-  auto &warnings = getShownPathDeprecationWarnings();
-  if (warnings.find(methodName) != warnings.end()) {
-    return;
-  }
-  warnings.insert(methodName);
-  std::string message =
-      std::string("[react-native-skia] SkPath.") + methodName +
-      "() is deprecated and will be removed in a future release. " +
-      suggestion +
-      " See migration guide: "
-      "https://shopify.github.io/react-native-skia/docs/shapes/path-migration";
-  RNSkLogger::warnToJavascriptConsole(runtime, message);
-}
-
 class JsiSkPath
     : public JsiSkWrappingSharedPtrNativeObject<JsiSkPath, SkPathBuilder> {
 public:
@@ -80,343 +56,6 @@ private:
   SkPath asPath() const { return getObject()->snapshot(); }
 
 public:
-  // Mutable building methods (deprecated) — chainable, and they take the
-  // runtime for the JS console deprecation warning.
-
-  void moveTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "moveTo",
-                             "Use Skia.PathBuilder.Make().moveTo() instead.");
-    getObject()->moveTo(x, y);
-  }
-
-  void rMoveTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "rMoveTo",
-                             "Use Skia.PathBuilder.Make().rMoveTo() instead.");
-    getObject()->rMoveTo({static_cast<SkScalar>(x), static_cast<SkScalar>(y)});
-  }
-
-  void lineTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "lineTo",
-                             "Use Skia.PathBuilder.Make().lineTo() instead.");
-    getObject()->lineTo(x, y);
-  }
-
-  void rLineTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "rLineTo",
-                             "Use Skia.PathBuilder.Make().rLineTo() instead.");
-    getObject()->rLineTo(x, y);
-  }
-
-  void quadTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-              double y2) {
-    warnDeprecatedPathMethod(runtime, "quadTo",
-                             "Use Skia.PathBuilder.Make().quadTo() instead.");
-    getObject()->quadTo(x1, y1, x2, y2);
-  }
-
-  void rQuadTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2) {
-    warnDeprecatedPathMethod(runtime, "rQuadTo",
-                             "Use Skia.PathBuilder.Make().rQuadTo() instead.");
-    getObject()->rQuadTo(x1, y1, x2, y2);
-  }
-
-  void conicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2, double w) {
-    warnDeprecatedPathMethod(runtime, "conicTo",
-                             "Use Skia.PathBuilder.Make().conicTo() instead.");
-    getObject()->conicTo(x1, y1, x2, y2, w);
-  }
-
-  void rConicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-                double y2, double w) {
-    warnDeprecatedPathMethod(runtime, "rConicTo",
-                             "Use Skia.PathBuilder.Make().rConicTo() instead.");
-    getObject()->rConicTo(x1, y1, x2, y2, w);
-  }
-
-  void cubicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2, double x3, double y3) {
-    warnDeprecatedPathMethod(runtime, "cubicTo",
-                             "Use Skia.PathBuilder.Make().cubicTo() instead.");
-    getObject()->cubicTo(x1, y1, x2, y2, x3, y3);
-  }
-
-  void rCubicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-                double y2, double x3, double y3) {
-    warnDeprecatedPathMethod(runtime, "rCubicTo",
-                             "Use Skia.PathBuilder.Make().rCubicTo() instead.");
-    getObject()->rCubicTo(x1, y1, x2, y2, x3, y3);
-  }
-
-  void close(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "close",
-                             "Use Skia.PathBuilder.Make().close() instead.");
-    getObject()->close();
-  }
-
-  void reset(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "reset",
-                             "Use Skia.PathBuilder.Make().reset() instead.");
-    getObject()->reset();
-  }
-
-  void rewind(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "rewind",
-                             "Use Skia.PathBuilder.Make().reset() instead.");
-    getObject()->reset();
-  }
-
-  void addPath(jsi::Runtime &runtime, std::shared_ptr<SkPathBuilder> src,
-               JsiOptional<std::shared_ptr<SkMatrix>> matrix,
-               JsiOptional<bool> extend) {
-    warnDeprecatedPathMethod(runtime, "addPath",
-                             "Use Skia.PathBuilder.Make().addPath() instead.");
-    auto srcPath = src->snapshot();
-    auto mode = extend.has_value() && *extend ? SkPath::kExtend_AddPathMode
-                                              : SkPath::kAppend_AddPathMode;
-    if (matrix.has_value()) {
-      getObject()->addPath(srcPath, **matrix, mode);
-    } else {
-      getObject()->addPath(srcPath, mode);
-    }
-  }
-
-  void addArc(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-              double start, double sweep) {
-    warnDeprecatedPathMethod(runtime, "addArc",
-                             "Use Skia.PathBuilder.Make().addArc() instead.");
-    getObject()->addArc(*rect, start, sweep);
-  }
-
-  void addOval(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-               JsiOptional<bool> isCCW, JsiOptional<double> startIndex) {
-    warnDeprecatedPathMethod(
-        runtime, "addOval",
-        "Use Skia.Path.Oval() or Skia.PathBuilder.Make().addOval() instead.");
-    getObject()->addOval(*rect, toDirection(isCCW),
-                         startIndex.has_value()
-                             ? static_cast<unsigned>(*startIndex)
-                             : 1);
-  }
-
-  void addRect(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-               JsiOptional<bool> isCCW) {
-    warnDeprecatedPathMethod(
-        runtime, "addRect",
-        "Use Skia.Path.Rect() or Skia.PathBuilder.Make().addRect() instead.");
-    getObject()->addRect(*rect, toDirection(isCCW));
-  }
-
-  void addRRect(jsi::Runtime &runtime, std::shared_ptr<SkRRect> rrect,
-                JsiOptional<bool> isCCW) {
-    warnDeprecatedPathMethod(
-        runtime, "addRRect",
-        "Use Skia.Path.RRect() or Skia.PathBuilder.Make().addRRect() instead.");
-    getObject()->addRRect(*rrect, toDirection(isCCW));
-  }
-
-  void addCircle(jsi::Runtime &runtime, double x, double y, double r) {
-    warnDeprecatedPathMethod(
-        runtime, "addCircle",
-        "Use Skia.Path.Circle() or Skia.PathBuilder.Make().addCircle() "
-        "instead.");
-    getObject()->addCircle(x, y, r);
-  }
-
-  void addPoly(jsi::Runtime &runtime, std::vector<SkPoint> points,
-               bool close) {
-    warnDeprecatedPathMethod(
-        runtime, "addPoly",
-        "Use Skia.Path.Polygon() or Skia.PathBuilder.Make().addPoly() "
-        "instead.");
-    getObject()->addPolygon(SkSpan<const SkPoint>(points.data(), points.size()),
-                            close);
-  }
-
-  void arcToOval(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-                 double start, double sweep, bool forceMoveTo) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToOval",
-        "Use Skia.PathBuilder.Make().arcToOval() instead.");
-    getObject()->arcTo(*rect, start, sweep, forceMoveTo);
-  }
-
-  void arcToRotated(jsi::Runtime &runtime, double rx, double ry,
-                    double xAxisRotate, bool useSmallArc, bool isCCW, double x,
-                    double y) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToRotated",
-        "Use Skia.PathBuilder.Make().arcToRotated() instead.");
-    auto arcSize = useSmallArc ? SkPathBuilder::kSmall_ArcSize
-                               : SkPathBuilder::kLarge_ArcSize;
-    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    getObject()->arcTo(SkPoint::Make(rx, ry), xAxisRotate, arcSize, sweep,
-                       SkPoint::Make(x, y));
-  }
-
-  void rArcTo(jsi::Runtime &runtime, double rx, double ry, double xAxisRotate,
-              bool useSmallArc, bool isCCW, double dx, double dy) {
-    warnDeprecatedPathMethod(runtime, "rArcTo",
-                             "Use Skia.PathBuilder.Make().rArcTo() instead.");
-    auto arcSize = useSmallArc ? SkPathBuilder::kSmall_ArcSize
-                               : SkPathBuilder::kLarge_ArcSize;
-    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    SkVector dxdy(dx, dy);
-    SkPoint r(rx, ry);
-    getObject()->rArcTo(r, xAxisRotate, arcSize, sweep, dxdy);
-  }
-
-  void arcToTangent(jsi::Runtime &runtime, double x1, double y1, double x2,
-                    double y2, double r) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToTangent",
-        "Use Skia.PathBuilder.Make().arcToTangent() instead.");
-    getObject()->arcTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), r);
-  }
-
-  void setFillType(jsi::Runtime &runtime, double ft) {
-    warnDeprecatedPathMethod(
-        runtime, "setFillType",
-        "Use Skia.PathBuilder.Make().setFillType() instead.");
-    getObject()->setFillType(static_cast<SkPathFillType>(static_cast<int>(ft)));
-  }
-
-  void setIsVolatile(jsi::Runtime &runtime, bool v) {
-    warnDeprecatedPathMethod(
-        runtime, "setIsVolatile",
-        "Use Skia.PathBuilder.Make().setIsVolatile() instead.");
-    getObject()->setIsVolatile(v);
-  }
-
-  // Mutable transform methods (deprecated)
-
-  void transform(jsi::Runtime &runtime, std::shared_ptr<SkMatrix> m3) {
-    warnDeprecatedPathMethod(
-        runtime, "transform",
-        "Use Skia.PathBuilder.Make().transform() instead.");
-    getObject()->transform(*m3);
-  }
-
-  void offset(jsi::Runtime &runtime, double dx, double dy) {
-    warnDeprecatedPathMethod(runtime, "offset",
-                             "Use Skia.PathBuilder.Make().offset() instead.");
-    getObject()->offset(dx, dy);
-  }
-
-  // Mutable path operations (deprecated)
-
-  void simplify(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "simplify",
-                             "Use Skia.Path.Simplify(path) instead.");
-    auto path = asPath();
-    auto result = ::Simplify(path);
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void op(jsi::Runtime &runtime, std::shared_ptr<SkPathBuilder> path2,
-          double pathOp) {
-    warnDeprecatedPathMethod(runtime, "op",
-                             "Use Skia.Path.MakeFromOp() instead.");
-    auto p1 = asPath();
-    auto p2 = path2->snapshot();
-    auto result =
-        ::Op(p1, p2, static_cast<SkPathOp>(static_cast<int>(pathOp)));
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void makeAsWinding(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "makeAsWinding",
-                             "Use Skia.Path.AsWinding(path) instead.");
-    auto path = asPath();
-    auto result = ::AsWinding(path);
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void dash(jsi::Runtime &runtime, double on, double off, double phase) {
-    warnDeprecatedPathMethod(
-        runtime, "dash", "Use Skia.Path.Dash(path, on, off, phase) instead.");
-    auto path = asPath();
-    SkScalar intervals[] = {static_cast<SkScalar>(on),
-                            static_cast<SkScalar>(off)};
-    auto pe = SkDashPathEffect::Make(SkSpan(intervals, 2), phase);
-    if (pe) {
-      SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-      SkPathBuilder resultBuilder;
-      if (pe->filterPath(&resultBuilder, path, &rec)) {
-        *getObject() = std::move(resultBuilder);
-      }
-    }
-  }
-
-  // Stays raw: the options object is read leniently property by property.
-  JSI_HOST_FUNCTION(stroke) {
-    warnDeprecatedPathMethod(runtime, "stroke",
-                             "Use Skia.Path.Stroke(path, opts) instead.");
-    auto path = asPath();
-    SkPaint p;
-    p.setStyle(SkPaint::kStroke_Style);
-
-    if (count > 0 && !arguments[0].isUndefined()) {
-      auto opts = arguments[0].asObject(runtime);
-
-      auto jsiCap = opts.getProperty(runtime, "cap");
-      if (!jsiCap.isUndefined()) {
-        p.setStrokeCap(
-            static_cast<SkPaint::Cap>(static_cast<int>(jsiCap.asNumber())));
-      }
-
-      auto jsiJoin = opts.getProperty(runtime, "join");
-      if (!jsiJoin.isUndefined()) {
-        p.setStrokeJoin(
-            static_cast<SkPaint::Join>(static_cast<int>(jsiJoin.asNumber())));
-      }
-
-      auto jsiWidth = opts.getProperty(runtime, "width");
-      if (!jsiWidth.isUndefined()) {
-        p.setStrokeWidth(jsiWidth.asNumber());
-      }
-
-      auto jsiMiterLimit = opts.getProperty(runtime, "miter_limit");
-      if (!jsiMiterLimit.isUndefined()) {
-        p.setStrokeMiter(jsiMiterLimit.asNumber());
-      }
-    }
-
-    SkPathBuilder resultBuilder;
-    auto success = skpathutils::FillPathWithPaint(path, p, &resultBuilder);
-    if (success) {
-      *getObject() = std::move(resultBuilder);
-    }
-    return thisValue.getObject(runtime);
-  }
-
-  void trim(jsi::Runtime &runtime, double startValue, double endValue,
-            bool isComplement) {
-    warnDeprecatedPathMethod(
-        runtime, "trim",
-        "Use Skia.Path.Trim(path, start, end, isComplement) instead.");
-    auto path = asPath();
-    float start = std::clamp(static_cast<float>(startValue), 0.0f, 1.0f);
-    float end = std::clamp(static_cast<float>(endValue), 0.0f, 1.0f);
-    auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
-                             : SkTrimPathEffect::Mode::kNormal;
-    auto pe = SkTrimPathEffect::Make(start, end, mode);
-    if (pe) {
-      SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-      SkPathBuilder resultBuilder;
-      if (pe->filterPath(&resultBuilder, path, &rec)) {
-        *getObject() = std::move(resultBuilder);
-      }
-    }
-  }
-
   // Query methods
 
   std::shared_ptr<JsiSkRect> computeTightBounds() {
@@ -540,76 +179,6 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    // Mutable building methods
-    installChainableMethodWithRuntime(runtime, prototype, "moveTo",
-                                      &JsiSkPath::moveTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rMoveTo",
-                                      &JsiSkPath::rMoveTo);
-    installChainableMethodWithRuntime(runtime, prototype, "lineTo",
-                                      &JsiSkPath::lineTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rLineTo",
-                                      &JsiSkPath::rLineTo);
-    installChainableMethodWithRuntime(runtime, prototype, "quadTo",
-                                      &JsiSkPath::quadTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rQuadTo",
-                                      &JsiSkPath::rQuadTo);
-    installChainableMethodWithRuntime(runtime, prototype, "conicTo",
-                                      &JsiSkPath::conicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rConicTo",
-                                      &JsiSkPath::rConicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "cubicTo",
-                                      &JsiSkPath::cubicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rCubicTo",
-                                      &JsiSkPath::rCubicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "close",
-                                      &JsiSkPath::close);
-    installChainableMethodWithRuntime(runtime, prototype, "reset",
-                                      &JsiSkPath::reset);
-    installChainableMethodWithRuntime(runtime, prototype, "rewind",
-                                      &JsiSkPath::rewind);
-    installChainableMethodWithRuntime(runtime, prototype, "addPath",
-                                      &JsiSkPath::addPath);
-    installChainableMethodWithRuntime(runtime, prototype, "addArc",
-                                      &JsiSkPath::addArc);
-    installChainableMethodWithRuntime(runtime, prototype, "addOval",
-                                      &JsiSkPath::addOval);
-    installChainableMethodWithRuntime(runtime, prototype, "addRect",
-                                      &JsiSkPath::addRect);
-    installChainableMethodWithRuntime(runtime, prototype, "addRRect",
-                                      &JsiSkPath::addRRect);
-    installChainableMethodWithRuntime(runtime, prototype, "addCircle",
-                                      &JsiSkPath::addCircle);
-    installChainableMethodWithRuntime(runtime, prototype, "addPoly",
-                                      &JsiSkPath::addPoly);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToOval",
-                                      &JsiSkPath::arcToOval);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToRotated",
-                                      &JsiSkPath::arcToRotated);
-    installChainableMethodWithRuntime(runtime, prototype, "rArcTo",
-                                      &JsiSkPath::rArcTo);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToTangent",
-                                      &JsiSkPath::arcToTangent);
-    installChainableMethodWithRuntime(runtime, prototype, "setFillType",
-                                      &JsiSkPath::setFillType);
-    installChainableMethodWithRuntime(runtime, prototype, "setIsVolatile",
-                                      &JsiSkPath::setIsVolatile);
-    // Mutable transform methods
-    installChainableMethodWithRuntime(runtime, prototype, "transform",
-                                      &JsiSkPath::transform);
-    installChainableMethodWithRuntime(runtime, prototype, "offset",
-                                      &JsiSkPath::offset);
-    // Mutable path operations
-    installChainableMethodWithRuntime(runtime, prototype, "simplify",
-                                      &JsiSkPath::simplify);
-    installChainableMethodWithRuntime(runtime, prototype, "op",
-                                      &JsiSkPath::op);
-    installChainableMethodWithRuntime(runtime, prototype, "makeAsWinding",
-                                      &JsiSkPath::makeAsWinding);
-    installChainableMethodWithRuntime(runtime, prototype, "dash",
-                                      &JsiSkPath::dash);
-    installHostMethod(runtime, prototype, "stroke", &JsiSkPath::stroke);
-    installChainableMethodWithRuntime(runtime, prototype, "trim",
-                                      &JsiSkPath::trim);
     // Query methods
     installMethod(runtime, prototype, "computeTightBounds",
                   &JsiSkPath::computeTightBounds);

package/cpp/api/JsiSkSkottie.h

@@ -34,7 +34,7 @@
 namespace RNSkia {
 namespace jsi = facebook::jsi;
 
-std::unique_ptr<SkCodec> DecodeImageData(sk_sp<SkData> data) {
+inline std::unique_ptr<SkCodec> DecodeImageData(sk_sp<SkData> data) {
   if (data == nullptr) {
     return nullptr;
   }
@@ -342,8 +342,7 @@ public:
     if (!slotID.has_value() || !scalar.has_value()) {
       return false;
     }
-    return getObject()->_slotManager->setScalarSlot(SkString(*slotID),
-                                                    *scalar);
+    return getObject()->_slotManager->setScalarSlot(SkString(*slotID), *scalar);
   }
 
   bool setVec2Slot(JsiOptional<std::string> slotID,

package/cpp/api/JsiSkStrutStyle.h

@@ -20,7 +20,7 @@ namespace jsi = facebook::jsi;
 
 namespace para = skia::textlayout;
 
-bool asBool(jsi::Runtime &runtime, const jsi::Value &value) {
+inline bool asBool(jsi::Runtime &runtime, const jsi::Value &value) {
   if (!value.isBool()) {
     throw jsi::JSError(runtime, "Expected boolean value");
   }

package/cpp/api/JsiSkSurfaceFactory.h

@@ -10,6 +10,10 @@
 
 #include "JsiSkSurface.h"
 
+#ifdef SK_GRAPHITE
+#include "rnskia/RNDawnContext.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -59,12 +63,49 @@ public:
                                       getContext(), std::move(surface)));
   }
 
+  // Pointer-based texture interop with react-native-webgpu, the surface
+  // counterpart of JsiSkImageFactory::MakeImageFromNativeTexture: Skia draws
+  // directly into a texture created on the shared device, so WebGPU can
+  // sample what Skia drew without any copy.
+  JSI_HOST_FUNCTION(MakeFromNativeTexture) {
+#ifdef SK_GRAPHITE
+    if (count < 1 || !arguments[0].isBigInt()) {
+      throw std::runtime_error("MakeFromNativeTexture requires a WGPUTexture "
+                               "pointer (BigInt), e.g. texture.nativePointer");
+    }
+    auto raw = reinterpret_cast<WGPUTexture>(
+        arguments[0].asBigInt(runtime).asUint64(runtime));
+    if (raw == nullptr) {
+      throw std::runtime_error(
+          "MakeFromNativeTexture: pointer must be non-null");
+    }
+    // AddRef so our wgpu::Texture holds its own reference: the surface keeps
+    // the texture alive for its lifetime, and the JS GPUTexture keeps its own
+    // reference, which the caller may release once the surface exists.
+    wgpuTextureAddRef(raw);
+    wgpu::Texture texture = wgpu::Texture::Acquire(raw);
+    auto surface = DawnContext::getInstance().MakeSurfaceFromTexture(texture);
+    if (surface == nullptr) {
+      throw std::runtime_error(
+          "MakeFromNativeTexture: failed to wrap the texture");
+    }
+    return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
+                                      getContext(), std::move(surface)));
+#else
+    throw std::runtime_error(
+        "MakeFromNativeTexture is only available with the Graphite backend. "
+        "Rebuild with SK_GRAPHITE enabled.");
+#endif
+  }
+
   size_t getMemoryPressure() override { return 2048; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installMethod(runtime, prototype, "Make", &JsiSkSurfaceFactory::Make);
     installHostMethod(runtime, prototype, "MakeOffscreen",
                       &JsiSkSurfaceFactory::MakeOffscreen);
+    installHostMethod(runtime, prototype, "MakeFromNativeTexture",
+                      &JsiSkSurfaceFactory::MakeFromNativeTexture);
   }
 
   explicit JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)