@shopify/react-native-skia 1.10.2 → 1.11.1

package/cpp/api/recorder/ImageFilters.h

@@ -0,0 +1,292 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "Command.h"
+#include "Convertor.h"
+#include "DrawingCtx.h"
+
+namespace RNSkia {
+
+struct BlurMaskFilterCmdProps {
+  float blur;
+  SkBlurStyle style;
+  bool respectCTM;
+};
+
+class BlurMaskFilterCmd : public Command {
+private:
+  BlurMaskFilterCmdProps props;
+
+public:
+  BlurMaskFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                    Variables &variables)
+      : Command(CommandType::PushBlurMaskFilter, "skBlurMaskFilter") {
+    convertProperty(runtime, object, "blur", props.blur, variables);
+    convertProperty(runtime, object, "style", props.style, variables);
+    convertProperty(runtime, object, "respectCTM", props.respectCTM, variables);
+  }
+
+  void pushMaskFilter(DrawingCtx *ctx) {
+    auto [blur, style, respectCTM] = props;
+    auto maskFilter = SkMaskFilter::MakeBlur(style, blur, respectCTM);
+    ctx->getPaint().setMaskFilter(maskFilter);
+  }
+};
+
+struct BlurImageFilterProps {
+  Radius blur;
+  SkTileMode mode;
+};
+
+class BlurImageFilterCmd : public Command {
+private:
+  BlurImageFilterProps props;
+
+public:
+  BlurImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                     Variables &variables)
+      : Command(CommandType::PushImageFilter, "skBlurImageFilter") {
+    convertProperty(runtime, object, "blur", props.blur, variables);
+    convertProperty(runtime, object, "mode", props.mode, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    auto imgf =
+        SkImageFilters::Blur(props.blur.rX, props.blur.rY, props.mode, nullptr);
+    ctx->imageFilters.push_back(imgf);
+  }
+};
+
+struct OffsetImageFilterProps {
+  float x;
+  float y;
+};
+
+class OffsetImageFilterCmd : public Command {
+private:
+  OffsetImageFilterProps props;
+
+public:
+  OffsetImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                       Variables &variables)
+      : Command(CommandType::PushImageFilter, "skOffsetImageFilter") {
+    convertProperty(runtime, object, "x", props.x, variables);
+    convertProperty(runtime, object, "y", props.y, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    auto imgf = SkImageFilters::Offset(props.x, props.y, nullptr);
+    ctx->imageFilters.push_back(imgf);
+  }
+};
+
+struct DisplacementMapImageFilterProps {
+  SkColorChannel channelX;
+  SkColorChannel channelY;
+  float scale;
+};
+
+class DisplacementMapImageFilterCmd : public Command {
+private:
+  DisplacementMapImageFilterProps props;
+
+public:
+  DisplacementMapImageFilterCmd(jsi::Runtime &runtime,
+                                const jsi::Object &object, Variables &variables)
+      : Command(CommandType::PushImageFilter, "skDisplacementMapImageFilter") {
+    convertProperty(runtime, object, "channelX", props.channelX, variables);
+    convertProperty(runtime, object, "channelY", props.channelY, variables);
+    convertProperty(runtime, object, "scale", props.scale, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    auto shader = ctx->shaders.back();
+    ctx->shaders.pop_back();
+    auto map = SkImageFilters::Shader(shader, nullptr);
+    auto imgf = SkImageFilters::DisplacementMap(props.channelX, props.channelY,
+                                                props.scale, map, nullptr);
+    ctx->imageFilters.push_back(imgf);
+  }
+};
+
+struct DropShadowImageFilterProps {
+  float dx;
+  float dy;
+  float blur;
+  SkColor color;
+  std::optional<bool> inner;
+  std::optional<bool> shadowOnly;
+};
+
+class DropShadowImageFilterCmd : public Command {
+private:
+  DropShadowImageFilterProps props;
+
+  sk_sp<SkImageFilter> MakeInnerShadow(bool shadowOnly, float dx, float dy,
+                                       float sigmaX, float sigmaY,
+                                       SkColor color,
+                                       sk_sp<SkImageFilter> input) {
+    auto sourceGraphic = SkImageFilters::ColorFilter(
+        SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kDst), nullptr);
+
+    auto sourceAlpha = SkImageFilters::ColorFilter(
+        SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kSrcIn), nullptr);
+
+    auto f1 = SkImageFilters::ColorFilter(
+        SkColorFilters::Blend(color, SkBlendMode::kSrcOut), nullptr);
+
+    auto f2 = SkImageFilters::Offset(dx, dy, f1);
+    auto f3 = SkImageFilters::Blur(sigmaX, sigmaY, SkTileMode::kDecal, f2);
+    auto f4 = SkImageFilters::Blend(SkBlendMode::kSrcIn, sourceAlpha, f3);
+
+    if (shadowOnly) {
+      return f4;
+    }
+
+    return SkImageFilters::Compose(
+        input, SkImageFilters::Blend(SkBlendMode::kSrcOver, sourceGraphic, f4));
+  }
+
+public:
+  DropShadowImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                           Variables &variables)
+      : Command(CommandType::PushImageFilter, "skDropShadowImageFilter") {
+    convertProperty(runtime, object, "dx", props.dx, variables);
+    convertProperty(runtime, object, "dy", props.dy, variables);
+    convertProperty(runtime, object, "blur", props.blur, variables);
+    convertProperty(runtime, object, "color", props.color, variables);
+    convertProperty(runtime, object, "inner", props.inner, variables);
+    convertProperty(runtime, object, "shadowOnly", props.shadowOnly, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    auto shadowOnly = props.shadowOnly.value_or(false);
+    auto inner = props.inner.value_or(false);
+
+    sk_sp<SkImageFilter> imgf;
+    if (inner) {
+      imgf = MakeInnerShadow(shadowOnly, props.dx, props.dy, props.blur,
+                             props.blur, props.color, nullptr);
+    } else {
+      if (shadowOnly) {
+        imgf = SkImageFilters::DropShadowOnly(props.dx, props.dy, props.blur,
+                                              props.blur, props.color, nullptr);
+      } else {
+        imgf = SkImageFilters::DropShadow(props.dx, props.dy, props.blur,
+                                          props.blur, props.color, nullptr);
+      }
+    }
+    ctx->imageFilters.push_back(imgf);
+  }
+};
+
+struct MorphologyImageFilterProps {
+  std::string op; // "erode" or "dilate"
+  Radius radius;
+};
+
+class MorphologyImageFilterCmd : public Command {
+private:
+  MorphologyImageFilterProps props;
+
+public:
+  MorphologyImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                           Variables &variables)
+      : Command(CommandType::PushImageFilter, "skMorphologyImageFilter") {
+    convertProperty(runtime, object, "operator", props.op, variables);
+    convertProperty(runtime, object, "radius", props.radius, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    if (props.op == "erode") {
+      auto imgf =
+          SkImageFilters::Erode(props.radius.rX, props.radius.rY, nullptr);
+      ctx->imageFilters.push_back(imgf);
+    } else {
+      auto imgf =
+          SkImageFilters::Dilate(props.radius.rX, props.radius.rY, nullptr);
+      ctx->imageFilters.push_back(imgf);
+    }
+  }
+};
+
+struct BlendImageFilterProps {
+  SkBlendMode mode;
+};
+
+class BlendImageFilterCmd : public Command {
+private:
+  BlendImageFilterProps props;
+
+public:
+  BlendImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                      Variables &variables)
+      : Command(CommandType::PushImageFilter, "skBlendImageFilter") {
+    convertProperty(runtime, object, "mode", props.mode, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    // Get all filters
+    auto filters = std::move(ctx->imageFilters);
+    ctx->imageFilters.clear();
+
+    // Create composer function
+    auto composer = [this](sk_sp<SkImageFilter> outer,
+                           sk_sp<SkImageFilter> inner) {
+      return SkImageFilters::Blend(props.mode, outer, inner);
+    };
+
+    // Compose filters
+    auto composedFilter = composeEffects<SkImageFilter>(filters, composer);
+
+    if (composedFilter) {
+      ctx->imageFilters.push_back(composedFilter);
+    }
+  }
+};
+
+struct RuntimeShaderImageFilterProps {
+  sk_sp<SkRuntimeEffect> source;
+  std::optional<Uniforms> uniforms;
+};
+
+class RuntimeShaderImageFilterCmd : public Command {
+private:
+  RuntimeShaderImageFilterProps props;
+
+public:
+  RuntimeShaderImageFilterCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                              Variables &variables)
+      : Command(CommandType::PushImageFilter, "skRuntimeShaderImageFilter") {
+    convertProperty(runtime, object, "source", props.source, variables);
+    convertProperty(runtime, object, "uniforms", props.uniforms, variables);
+  }
+
+  void pushImageFilter(DrawingCtx *ctx) {
+    if (props.source) {
+      // Create the runtime shader builder
+      SkRuntimeShaderBuilder builder(props.source);
+
+      // Process uniforms if present
+      if (props.uniforms.has_value()) {
+        processUniforms(builder, props.source, props.uniforms.value());
+      }
+
+      // Get the input filter (if any)
+      sk_sp<SkImageFilter> input = nullptr;
+      if (!ctx->imageFilters.empty()) {
+        input = ctx->imageFilters.back();
+        ctx->imageFilters.pop_back();
+      }
+
+      // Create and push the runtime shader image filter
+      auto imgf = SkImageFilters::RuntimeShader(builder, "", input);
+      ctx->imageFilters.push_back(imgf);
+    }
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/recorder/ImageFit.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <string>
+
+#include <include/core/SkMatrix.h>
+#include <include/core/SkRect.h>
+
+// TODO: to rename once the old reconciler is removed
+namespace RNSkiaImage {
+
+struct FitSizes {
+  SkSize src;
+  SkSize dst;
+};
+
+struct FitRects {
+  SkRect src;
+  SkRect dst;
+};
+
+SkRect inscribe(SkSize size, SkRect rect) {
+  auto halfWidthDelta = (rect.width() - size.width()) / 2.0;
+  auto halfHeightDelta = (rect.height() - size.height()) / 2.0;
+  return SkRect::MakeXYWH(rect.x() + halfWidthDelta, rect.y() + halfHeightDelta,
+                          size.width(), size.height());
+}
+
+SkMatrix rect2rect(SkRect src, SkRect dst) {
+  auto sx = dst.width() / src.width();
+  auto sy = dst.height() / src.height();
+  auto tx = dst.x() - src.x() * sx;
+  auto ty = dst.y() - src.y() * sy;
+  SkMatrix m3;
+  m3.preTranslate(tx, ty);
+  m3.preScale(sx, sy);
+  return m3;
+}
+
+SkSize size(double width, double height) { return SkSize::Make(width, height); }
+
+FitSizes applyBoxFit(const std::string fit, SkSize input, SkSize output) {
+  SkSize src = size(0, 0);
+  SkSize dst = size(0, 0);
+
+  if (input.height() <= 0.0 || input.width() <= 0.0 || output.height() <= 0.0 ||
+      output.width() <= 0.0) {
+    return {.src = src, .dst = dst};
+  }
+
+  if (fit == "fill") {
+    src = input;
+    dst = output;
+  } else if (fit == "contain") {
+    src = input;
+    if (output.width() / output.height() > src.width() / src.height()) {
+      dst =
+          size((src.width() * output.height()) / src.height(), output.height());
+    } else {
+      dst = size(output.width(), (src.height() * output.width()) / src.width());
+    }
+  } else if (fit == "cover") {
+    if (output.width() / output.height() > input.width() / input.height()) {
+      src = size(input.width(),
+                 (input.width() * output.height()) / output.width());
+    } else {
+      src = size((input.height() * output.width()) / output.height(),
+                 input.height());
+    }
+    dst = output;
+  } else if (fit == "fitWidth") {
+    src =
+        size(input.width(), (input.width() * output.height()) / output.width());
+    dst = size(output.width(), (src.height() * output.width()) / src.width());
+  } else if (fit == "fitHeight") {
+    src = size((input.height() * output.width()) / output.height(),
+               input.height());
+    dst = size((src.width() * output.height()) / src.height(), output.height());
+  } else if (fit == "none") {
+    src = size(std::min(input.width(), output.width()),
+               std::min(input.height(), output.height()));
+    dst = src;
+  } else if (fit == "scaleDown") {
+    src = input;
+    dst = input;
+    auto aspectRatio = input.width() / input.height();
+    if (dst.height() > output.height()) {
+      dst = size(output.height() * aspectRatio, output.height());
+    }
+    if (dst.width() > output.width()) {
+      dst = size(output.width(), output.width() / aspectRatio);
+    }
+  } else {
+    throw std::runtime_error("The value \"" + fit +
+                             "\" is not a valid fit value.");
+  }
+  return {.src = src, .dst = dst};
+}
+
+FitRects fitRects(const std::string &fit, SkRect rect, SkRect rect2) {
+  auto sizes = applyBoxFit(fit, size(rect.width(), rect.height()),
+                           size(rect2.width(), rect2.height()));
+
+  auto src = inscribe(sizes.src, rect);
+  auto dst = inscribe(sizes.dst, rect2);
+
+  return {.src = src, .dst = dst};
+}
+} // namespace RNSkiaImage

package/cpp/api/recorder/JsiRecorder.h

@@ -0,0 +1,314 @@
+#pragma once
+
+#include <memory>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "JsiSkCanvas.h"
+#include "JsiSkHostObjects.h"
+
+#include "DrawingCtx.h"
+#include "RNRecorder.h"
+#include "RNSkLog.h"
+
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiRecorder : public JsiSkWrappingSharedPtrHostObject<Recorder> {
+public:
+  JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkWrappingSharedPtrHostObject(std::move(context),
+                                         std::make_shared<Recorder>()) {}
+
+  JSI_HOST_FUNCTION(savePaint) {
+    getObject()->savePaint(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(materializePaint) {
+    getObject()->materializePaint();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawCircle) {
+    getObject()->drawCircle(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(restorePaint) {
+    getObject()->restorePaint();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawPaint) {
+    getObject()->drawPaint();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(play) {
+    auto jsiCanvas =
+        arguments[0].asObject(runtime).asHostObject<JsiSkCanvas>(runtime);
+    DrawingCtx ctx(jsiCanvas->getCanvas());
+    getObject()->play(&ctx);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(applyUpdates) {
+    auto values = arguments[0].asObject(runtime).asArray(runtime);
+    auto size = values.size(runtime);
+    auto recorder = getObject();
+    for (int i = 0; i < size; i++) {
+      auto sharedValue = values.getValueAtIndex(runtime, i).asObject(runtime);
+      auto name = "variable" + std::to_string(i);
+      // Look up the conversion functions for this name
+      auto it = recorder->variables.find(name);
+      if (it != recorder->variables.end()) {
+        // Execute each conversion function in the vector
+        const auto &conversionFunctions = it->second;
+        for (const auto &conversionFunc : conversionFunctions) {
+          conversionFunc(runtime, sharedValue);
+        }
+      }
+    }
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(saveGroup) {
+    getObject()->saveGroup();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(restoreGroup) {
+    getObject()->restoreGroup();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(restorePaintDeclaration) {
+    getObject()->restorePaintDeclaration();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pushPathEffect) {
+    getObject()->pushPathEffect(runtime,
+                                arguments[0].asString(runtime).utf8(runtime),
+                                arguments[1].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pushImageFilter) {
+    getObject()->pushImageFilter(runtime,
+                                 arguments[0].asString(runtime).utf8(runtime),
+                                 arguments[1].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pushColorFilter) {
+    getObject()->pushColorFilter(runtime,
+                                 arguments[0].asString(runtime).utf8(runtime),
+                                 arguments[1].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pushShader) {
+    getObject()->pushShader(runtime,
+                            arguments[0].asString(runtime).utf8(runtime),
+                            arguments[1].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pushBlurMaskFilter) {
+    getObject()->pushBlurMaskFilter(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(composePathEffect) {
+    getObject()->composePathEffect();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(composeColorFilter) {
+    getObject()->composeColorFilter();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(composeImageFilter) {
+    getObject()->composeImageFilter();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(saveCTM) {
+    getObject()->saveCTM(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(restoreCTM) {
+    getObject()->restoreCTM();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(saveLayer) {
+    getObject()->saveLayer();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(saveBackdropFilter) {
+    getObject()->saveBackdropFilter();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawBox) {
+    auto boxProps = arguments[0].asObject(runtime);
+    auto shadowsArray = arguments[1].asObject(runtime).asArray(runtime);
+    getObject()->drawBox(runtime, boxProps, shadowsArray);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawImage) {
+    getObject()->drawImage(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawPoints) {
+    getObject()->drawPoints(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawPath) {
+    getObject()->drawPath(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawRect) {
+    getObject()->drawRect(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawRRect) {
+    getObject()->drawRRect(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawOval) {
+    getObject()->drawOval(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawLine) {
+    getObject()->drawLine(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawPatch) {
+    getObject()->drawPatch(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawVertices) {
+    getObject()->drawVertices(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawDiffRect) {
+    getObject()->drawDiffRect(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawText) {
+    getObject()->drawText(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawTextPath) {
+    getObject()->drawTextPath(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawTextBlob) {
+    getObject()->drawTextBlob(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawGlyphs) {
+    getObject()->drawGlyphs(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawPicture) {
+    getObject()->drawPicture(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawImageSVG) {
+    getObject()->drawImageSVG(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawParagraph) {
+    getObject()->drawParagraph(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(drawAtlas) {
+    getObject()->drawAtlas(runtime, arguments[0].asObject(runtime));
+    return jsi::Value::undefined();
+  }
+
+  EXPORT_JSI_API_TYPENAME(JsiRecorder, Recorder)
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiRecorder, saveGroup),
+                       JSI_EXPORT_FUNC(JsiRecorder, restoreGroup),
+                       JSI_EXPORT_FUNC(JsiRecorder, savePaint),
+                       JSI_EXPORT_FUNC(JsiRecorder, restorePaint),
+                       JSI_EXPORT_FUNC(JsiRecorder, restorePaintDeclaration),
+                       JSI_EXPORT_FUNC(JsiRecorder, materializePaint),
+                       JSI_EXPORT_FUNC(JsiRecorder, pushPathEffect),
+                       JSI_EXPORT_FUNC(JsiRecorder, pushImageFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, pushColorFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, pushShader),
+                       JSI_EXPORT_FUNC(JsiRecorder, pushBlurMaskFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, composePathEffect),
+                       JSI_EXPORT_FUNC(JsiRecorder, composeColorFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, composeImageFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, saveCTM),
+                       JSI_EXPORT_FUNC(JsiRecorder, restoreCTM),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawPaint),
+                       JSI_EXPORT_FUNC(JsiRecorder, saveLayer),
+                       JSI_EXPORT_FUNC(JsiRecorder, saveBackdropFilter),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawBox),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawImage),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawCircle),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawPoints),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawPath),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawRect),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawRRect),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawOval),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawLine),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawPatch),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawVertices),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawDiffRect),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawText),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawTextPath),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawTextBlob),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawGlyphs),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawPicture),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawImageSVG),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawParagraph),
+                       JSI_EXPORT_FUNC(JsiRecorder, drawAtlas),
+                       JSI_EXPORT_FUNC(JsiRecorder, play),
+                       JSI_EXPORT_FUNC(JsiRecorder, applyUpdates))
+
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiRecorder>(std::move(context)));
+    };
+  }
+};
+
+} // namespace RNSkia