@pompadour/react-native-skia 1.4.0

package/cpp/api/JsiSkShader.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkShader.h"
+#include "include/effects/SkGradientShader.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkShader : public JsiSkWrappingSkPtrHostObject<SkShader> {
+public:
+  JsiSkShader(std::shared_ptr<RNSkPlatformContext> context,
+              sk_sp<SkShader> shader)
+      : JsiSkWrappingSkPtrHostObject<SkShader>(std::move(context),
+                                               std::move(shader)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkShader, Shader)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShader, dispose))
+};
+} // namespace RNSkia

package/cpp/api/JsiSkShaderFactory.h

@@ -0,0 +1,226 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkColorFilter.h"
+#include "include/effects/SkImageFilters.h"
+#include "include/effects/SkPerlinNoiseShader.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+int getFlag(const jsi::Value *values, int i, size_t size) {
+  if (i >= size || values[i].isUndefined()) {
+    return 0;
+  }
+  return values[i].asNumber();
+}
+
+SkMatrix *getLocalMatrix(jsi::Runtime &runtime, const jsi::Value *values, int i,
+                         size_t size) {
+  if (i >= size || values[i].isUndefined()) {
+    return nullptr;
+  }
+  return JsiSkMatrix::fromValue(runtime, values[i]).get();
+}
+
+SkTileMode getTileMode(const jsi::Value *values, int i, size_t size) {
+  if (i >= size || values[i].isUndefined()) {
+    return SkTileMode::kClamp;
+  }
+  return static_cast<SkTileMode>(values[i].asNumber());
+}
+
+std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value &value) {
+  std::vector<SkColor> colors;
+  if (!value.isNull()) {
+    auto jsiColors = value.asObject(runtime).asArray(runtime);
+    auto size = jsiColors.size(runtime);
+    colors.reserve(size);
+    for (int i = 0; i < size; i++) {
+      SkColor color =
+          JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
+      colors.push_back(color);
+    }
+  }
+  return colors;
+}
+
+std::vector<SkScalar> getPositions(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+  std::vector<SkScalar> positions;
+  if (!value.isNull()) {
+    auto jsiPositions = value.asObject(runtime).asArray(runtime);
+    auto size = jsiPositions.size(runtime);
+    positions.reserve(size);
+    for (int i = 0; i < size; i++) {
+      SkScalar position = jsiPositions.getValueAtIndex(runtime, i).asNumber();
+      positions.push_back(position);
+    }
+  }
+  return positions;
+}
+
+class JsiSkShaderFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeLinearGradient) {
+    auto p1 =
+        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
+    auto p2 =
+        *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
+    SkPoint pts[] = {p1, p2};
+
+    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    auto tileMode = getTileMode(arguments, 4, count);
+    auto flag = getFlag(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
+        pts, colors.data(), positions.data(), static_cast<int>(colors.size()),
+        tileMode, flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeRadialGradient) {
+    auto center =
+        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
+    auto r = arguments[1].asNumber();
+
+    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    auto tileMode = getTileMode(arguments, 4, count);
+    auto flag = getFlag(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeRadial(
+        center, r, colors.data(), positions.data(),
+        static_cast<int>(colors.size()), tileMode, flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeSweepGradient) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    auto tileMode = getTileMode(arguments, 4, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
+    auto flag = getFlag(arguments, 6, count);
+    auto startAngle =
+        (count < 8 || arguments[7].isUndefined()) ? 0 : arguments[7].asNumber();
+    auto endAngle = (count < 9 || arguments[8].isUndefined())
+                        ? 360
+                        : arguments[8].asNumber();
+    sk_sp<SkShader> gradient = SkGradientShader::MakeSweep(
+        x, y, colors.data(), positions.data(), static_cast<int>(colors.size()),
+        tileMode, startAngle, endAngle, flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeTwoPointConicalGradient) {
+    auto start =
+        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
+    auto startRadius = arguments[1].asNumber();
+
+    auto end =
+        *JsiSkPoint::fromValue(runtime, arguments[2].asObject(runtime)).get();
+    auto endRadius = arguments[3].asNumber();
+
+    std::vector<SkColor> colors = getColors(runtime, arguments[4]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[5]);
+    auto tileMode = getTileMode(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
+    auto flag = getFlag(arguments, 8, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeTwoPointConical(
+        start, startRadius, end, endRadius, colors.data(), positions.data(),
+        static_cast<int>(colors.size()), tileMode, flag, localMatrix);
+
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeTurbulence) {
+    auto baseFreqX = arguments[0].asNumber();
+    auto baseFreqY = arguments[1].asNumber();
+    auto octaves = arguments[2].asNumber();
+    auto seed = arguments[3].asNumber();
+    auto tileW = arguments[4].asNumber();
+    auto tileH = arguments[5].asNumber();
+    SkISize size = SkISize::Make(tileW, tileH);
+    sk_sp<SkShader> gradient =
+        SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFractalNoise) {
+    auto baseFreqX = arguments[0].asNumber();
+    auto baseFreqY = arguments[1].asNumber();
+    auto octaves = arguments[2].asNumber();
+    auto seed = arguments[3].asNumber();
+    auto tileW = arguments[4].asNumber();
+    auto tileH = arguments[5].asNumber();
+    SkISize size = SkISize::Make(tileW, tileH);
+    sk_sp<SkShader> gradient =
+        SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeBlend) {
+    auto blendMode = (SkBlendMode)arguments[0].asNumber();
+    auto one = JsiSkShader::fromValue(runtime, arguments[1]);
+    auto two = JsiSkShader::fromValue(runtime, arguments[2]);
+    sk_sp<SkShader> gradient = SkShaders::Blend(blendMode, one, two);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeColor) {
+    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
+    sk_sp<SkShader> gradient = SkShaders::Color(color);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeLinearGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeRadialGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeSweepGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory,
+                                       MakeTwoPointConicalGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeTurbulence),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeFractalNoise),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeBlend),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeColor))
+
+  explicit JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkStrutStyle.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "modules/skparagraph/include/Paragraph.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+bool asBool(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (!value.isBool()) {
+    throw jsi::JSError(runtime, "Expected boolean value");
+  }
+  return value.getBool();
+}
+
+/**
+ Implementation of the TextStyle object in JSI for the paragraph builder
+ */
+class JsiSkStrutStyle {
+public:
+  static para::StrutStyle fromValue(jsi::Runtime &runtime,
+                                    const jsi::Value &value) {
+    // Read values from the argument - expected to be a TextStyle shaped object
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime, "Expected SkStrutStyle as first argument");
+    }
+    /**
+      strutEnabled?: boolean;
+      fontFamilies?: string[];
+      fontStyle?: SkTextFontStyle;
+      fontSize?: number;
+      heightMultiplier?: number;
+      halfLeading?: boolean;
+      leading?: number;
+      forceStrutHeight?: boolean;
+     */
+    auto object = value.asObject(runtime);
+
+    para::StrutStyle retVal;
+
+    if (object.hasProperty(runtime, "strutEnabled")) {
+      auto propValue = object.getProperty(runtime, "strutEnabled");
+      retVal.setStrutEnabled(asBool(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "fontFamilies")) {
+      auto propValue = object.getProperty(runtime, "fontFamilies")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      std::vector<SkString> families(size);
+      for (size_t i = 0; i < size; ++i) {
+        families[i] = propValue.getValueAtIndex(runtime, i)
+                          .asString(runtime)
+                          .utf8(runtime)
+                          .c_str();
+      }
+    }
+
+    if (object.hasProperty(runtime, "fontStyle")) {
+      auto propValue = object.getProperty(runtime, "fontStyle");
+      retVal.setFontStyle(*JsiSkFontStyle::fromValue(runtime, propValue).get());
+    }
+    if (object.hasProperty(runtime, "fontSize")) {
+      auto propValue = object.getProperty(runtime, "fontSize");
+      retVal.setFontSize(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "heightMultiplier")) {
+      auto propValue = object.getProperty(runtime, "heightMultiplier");
+      retVal.setHeight(propValue.asNumber());
+      retVal.setHeightOverride(true);
+    }
+    if (object.hasProperty(runtime, "halfLeading")) {
+      auto propValue = object.getProperty(runtime, "halfLeading");
+      retVal.setHalfLeading(asBool(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "leading")) {
+      auto propValue = object.getProperty(runtime, "leading");
+      retVal.setLeading(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "forceStrutHeight")) {
+      auto propValue = object.getProperty(runtime, "forceStrutHeight");
+      retVal.setForceStrutHeight(asBool(runtime, propValue));
+    }
+
+    return retVal;
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#include "JsiSkCanvas.h"
+#include "JsiSkImage.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkSurface.h"
+#include "include/gpu/GrDirectContext.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
+public:
+  JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
+               sk_sp<SkSurface> surface)
+      : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context),
+                                                std::move(surface)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkSurface, Surface)
+
+  // TODO-API: Properties?
+  JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
+  JSI_HOST_FUNCTION(height) {
+    return static_cast<double>(getObject()->height());
+  }
+
+  JSI_HOST_FUNCTION(getCanvas) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas()));
+  }
+
+  JSI_HOST_FUNCTION(flush) {
+    if (auto dContext = GrAsDirectContext(getObject()->recordingContext())) {
+      dContext->flushAndSubmit();
+    }
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(makeImageSnapshot) {
+    sk_sp<SkImage> image;
+    if (count == 1) {
+      auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+      image = getObject()->makeImageSnapshot(SkIRect::MakeXYWH(
+          rect->x(), rect->y(), rect->width(), rect->height()));
+    } else {
+      image = getObject()->makeImageSnapshot();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, width),
+                       JSI_EXPORT_FUNC(JsiSkSurface, height),
+                       JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
+                       JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot),
+                       JSI_EXPORT_FUNC(JsiSkSurface, flush),
+                       JSI_EXPORT_FUNC(JsiSkSurface, dispose))
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSurfaceFactory.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#include "JsiSkSurface.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkSurface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkSurfaceFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    auto width = static_cast<int>(arguments[0].asNumber());
+    auto height = static_cast<int>(arguments[1].asNumber());
+    auto imageInfo = SkImageInfo::MakeN32Premul(width, height);
+    auto surface = SkSurfaces::Raster(imageInfo);
+    if (surface == nullptr) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+  }
+
+  JSI_HOST_FUNCTION(MakeOffscreen) {
+    auto width = static_cast<int>(arguments[0].asNumber());
+    auto height = static_cast<int>(arguments[1].asNumber());
+    auto context = getContext();
+    auto surface = context->makeOffscreenSurface(width, height);
+    if (surface == nullptr) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make),
+                       JSI_EXPORT_FUNC(JsiSkSurfaceFactory, MakeOffscreen))
+
+  explicit JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTextBlob.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkTextBlob.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkTextBlob : public JsiSkWrappingSkPtrHostObject<SkTextBlob> {
+public:
+  JsiSkTextBlob(std::shared_ptr<RNSkPlatformContext> context,
+                sk_sp<SkTextBlob> shader)
+      : JsiSkWrappingSkPtrHostObject<SkTextBlob>(std::move(context),
+                                                 std::move(shader)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkTextBlob, TextBlob)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlob, dispose))
+};
+} // namespace RNSkia

package/cpp/api/JsiSkTextBlobFactory.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkFont.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkRSXform.h"
+#include "JsiSkTextBlob.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkTextBlob.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkTextBlobFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeFromText) {
+    auto str = arguments[0].asString(runtime).utf8(runtime);
+    auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+    auto textBlob = SkTextBlob::MakeFromString(str.c_str(), *font);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromGlyphs) {
+    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+    auto font = JsiSkFont::fromValue(runtime, arguments[1]);
+    int bytesPerGlyph = 2;
+    std::vector<SkGlyphID> glyphs;
+    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+    glyphs.reserve(glyphsSize);
+    for (int i = 0; i < glyphsSize; i++) {
+      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+    }
+    auto textBlob =
+        SkTextBlob::MakeFromText(glyphs.data(), glyphs.size() * bytesPerGlyph,
+                                 *font, SkTextEncoding::kGlyphID);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromRSXform) {
+    auto str = arguments[0].asString(runtime).utf8(runtime);
+    auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
+    auto font = JsiSkFont::fromValue(runtime, arguments[2]);
+    std::vector<SkRSXform> rsxforms;
+    int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
+    rsxforms.reserve(rsxformsSize);
+    for (int i = 0; i < rsxformsSize; i++) {
+      auto rsxform = JsiSkRSXform::fromValue(
+          runtime, jsiRsxforms.getValueAtIndex(runtime, i));
+      rsxforms.push_back(*rsxform);
+    }
+    auto textBlob = SkTextBlob::MakeFromRSXform(str.c_str(), str.length(),
+                                                rsxforms.data(), *font);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+  }
+
+  JSI_HOST_FUNCTION(MakeFromRSXformGlyphs) {
+    auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+    auto jsiRsxforms = arguments[1].asObject(runtime).asArray(runtime);
+    auto font = JsiSkFont::fromValue(runtime, arguments[2]);
+    int bytesPerGlyph = 2;
+    std::vector<SkGlyphID> glyphs;
+    int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+    glyphs.reserve(glyphsSize);
+    for (int i = 0; i < glyphsSize; i++) {
+      glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+    }
+    std::vector<SkRSXform> rsxforms;
+    int rsxformsSize = static_cast<int>(jsiRsxforms.size(runtime));
+    rsxforms.reserve(rsxformsSize);
+    for (int i = 0; i < rsxformsSize; i++) {
+      auto rsxform = JsiSkRSXform::fromValue(
+          runtime, jsiRsxforms.getValueAtIndex(runtime, i));
+      rsxforms.push_back(*rsxform);
+    }
+    auto textBlob = SkTextBlob::MakeFromRSXform(
+        glyphs.data(), glyphs.size() * bytesPerGlyph, rsxforms.data(), *font,
+        SkTextEncoding::kGlyphID);
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromText),
+                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromGlyphs),
+                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromRSXform),
+                       JSI_EXPORT_FUNC(JsiSkTextBlobFactory,
+                                       MakeFromRSXformGlyphs), )
+
+  explicit JsiSkTextBlobFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia