@shopify/react-native-skia 0.0.135

package/cpp/api/JsiSkRSXform.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRSXform.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkRSXform : public JsiSkWrappingSharedPtrHostObject<SkRSXform> {
+    public:
+        JsiSkRSXform(std::shared_ptr<RNSkPlatformContext> context, const SkRSXform &rsxform)
+                : JsiSkWrappingSharedPtrHostObject<SkRSXform>(
+                std::move(context), std::make_shared<SkRSXform>(rsxform)){}
+
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+
+        JSI_PROPERTY_GET(__typename__) {
+          return jsi::String::createFromUtf8(runtime, "RSXform");
+        }
+
+        JSI_PROPERTY_GET(scos) {
+          return jsi::Value(SkScalarToDouble(getObject()->fSCos));
+        }
+        JSI_PROPERTY_GET(ssin) {
+          return jsi::Value(SkScalarToDouble(getObject()->fSSin));
+        }
+        JSI_PROPERTY_GET(tx) {
+          return jsi::Value(SkScalarToDouble(getObject()->fTx));
+        }
+        JSI_PROPERTY_GET(ty) {
+          return jsi::Value(SkScalarToDouble(getObject()->fTy));
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, __typename__),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, scos),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, ssin),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, tx),
+            JSI_EXPORT_PROP_GET(JsiSkRSXform, ty),
+        )
+
+        /**
+        Returns the underlying object from a host object of this type
+       */
+        static std::shared_ptr<SkRSXform> fromValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &obj) {
+            const auto& object = obj.asObject(runtime);
+            if (object.isHostObject(runtime)) {
+                return object
+                        .asHostObject<JsiSkRSXform>(runtime)
+                        ->getObject();
+            } else {
+                auto scos = object.getArray(runtime).getValueAtIndex(runtime, 0).asNumber();
+                auto ssin = object.getArray(runtime).getValueAtIndex(runtime, 1).asNumber();
+                auto tx = object.getArray(runtime).getValueAtIndex(runtime, 2).asNumber();
+                auto ty = object.getArray(runtime).getValueAtIndex(runtime, 3).asNumber();
+                return std::make_shared<SkRSXform>(SkRSXform::Make(scos, ssin, tx, ty));
+            }
+        }
+
+        /**
+        Returns the jsi object from a host object of this type
+       */
+        static jsi::Value toValue(jsi::Runtime &runtime,
+                                  std::shared_ptr<RNSkPlatformContext> context,
+                                  const SkRSXform &rsxform) {
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRSXform>(std::move(context), rsxform));
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkRSXform
+         * wrapper
+         * @param context platform context
+         * @return A function for creating a new host object wrapper for the SkRSXform
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+            return JSI_HOST_FUNCTION_LAMBDA {
+                    auto rsxform = SkRSXform::Make(
+                            arguments[0].asNumber(),
+                            arguments[1].asNumber(),
+                            arguments[2].asNumber(),
+                            arguments[3].asNumber()
+                    );
+                    // Return the newly constructed object
+                    return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRSXform>(std::move(context), std::move(rsxform)));
+            };
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkRect.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRect : public JsiSkWrappingSharedPtrHostObject<SkRect> {
+public:
+  JSI_PROPERTY_GET(x) { return static_cast<double>(getObject()->x()); }
+  JSI_PROPERTY_GET(y) { return static_cast<double>(getObject()->y()); }
+  JSI_PROPERTY_GET(width) { return static_cast<double>(getObject()->width()); }
+  JSI_PROPERTY_GET(height) {
+    return static_cast<double>(getObject()->height());
+  }
+  JSI_PROPERTY_GET(left) { return static_cast<double>(getObject()->left()); }
+  JSI_PROPERTY_GET(top) { return static_cast<double>(getObject()->top()); }
+  JSI_PROPERTY_GET(right) { return static_cast<double>(getObject()->right()); }
+  JSI_PROPERTY_GET(bottom) {
+    return static_cast<double>(getObject()->bottom());
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkRect, x),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, y),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, width),
+                              JSI_EXPORT_PROP_GET(JsiSkRect, height))
+
+  JSI_HOST_FUNCTION(setXYWH) {
+    getObject()->setXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
+                         arguments[2].asNumber(), arguments[3].asNumber());
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(setLTRB) {
+    getObject()->setLTRB(arguments[0].asNumber(), arguments[1].asNumber(),
+                         arguments[2].asNumber(), arguments[3].asNumber());
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRect, setXYWH),
+                       JSI_EXPORT_FUNC(JsiSkRect, setLTRB), )
+
+  /**
+   Constructor
+   */
+  JsiSkRect(std::shared_ptr<RNSkPlatformContext> context, const SkRect &rect)
+      : JsiSkWrappingSharedPtrHostObject<SkRect>(
+            std::move(context), std::make_shared<SkRect>(rect)){}
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static std::shared_ptr<SkRect> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+    const auto& object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return object
+              .asHostObject<JsiSkRect>(runtime)
+              ->getObject();
+    } else {
+      auto x = object.getProperty(runtime, "x").asNumber();
+      auto y = object.getProperty(runtime, "y").asNumber();
+      auto width = object.getProperty(runtime, "width").asNumber();
+      auto height = object.getProperty(runtime, "height").asNumber();
+      return std::make_shared<SkRect>(SkRect::MakeXYWH(x, y, width, height));
+    }
+  }
+
+  /**
+    Returns the jsi object from a host object of this type
+   */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkRect &rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(std::move(context), rect));
+  }
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            SkRect&& rect) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(std::move(context), std::move(rect)));
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkRect
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the SkRect
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      // Set up the rect
+      SkRect rect =
+          SkRect::MakeXYWH(arguments[0].asNumber(), arguments[1].asNumber(),
+                           arguments[2].asNumber(), arguments[3].asNumber());
+
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkRect>(std::move(context), std::move(rect)));
+    };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkRuntimeEffect.h

@@ -0,0 +1,222 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <JsiSkHostObjects.h>
+#include <JsiSkShader.h>
+#include <JsiSkMatrix.h>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRuntimeEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia
+{
+
+  using namespace facebook;
+
+  struct RuntimeEffectUniform
+  {
+    int columns;
+    int rows;
+    int slot; // the index into the uniforms array that this uniform begins.
+    bool isInteger;
+  };
+
+  class JsiSkRuntimeEffect
+      : public JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>
+  {
+  public:
+      
+    static sk_sp<SkRuntimeEffect> fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+        const auto& object = obj.asObject(runtime);
+        return object.asHostObject<JsiSkRuntimeEffect>(runtime)->getObject();
+    }
+
+    JSI_HOST_FUNCTION(makeShader)
+    {
+      auto uniforms = castUniforms(runtime, arguments[0]);
+      
+      auto matrix = count >= 2 && !arguments[1].isUndefined()  && !arguments[1].isNull()  ? JsiSkMatrix::fromValue(runtime, arguments[1]).get() : nullptr;
+
+      // Create and return shader as host object
+      auto shader = getObject()->makeShader(std::move(uniforms), nullptr, 0, matrix);
+
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(makeShaderWithChildren)
+    {
+      auto uniforms = castUniforms(runtime, arguments[0]);
+      
+      // Children
+      std::vector<sk_sp<SkShader>> children;
+      auto jsiChildren = arguments[1].asObject(runtime).asArray(runtime);
+      auto jsiChildCount = jsiChildren.size(runtime);
+      children.reserve(jsiChildCount);
+      for (int i = 0; i < jsiChildCount; i++)
+      {
+        auto shader = jsiChildren.getValueAtIndex(runtime, i)
+                          .asObject(runtime)
+                          .asHostObject<JsiSkShader>(runtime)
+                          ->getObject();
+        children.push_back(shader);
+      }
+
+      auto matrix = count >= 3 && !arguments[2].isUndefined()  && !arguments[2].isNull() ? JsiSkMatrix::fromValue(runtime, arguments[2]).get() : nullptr;
+
+      // Create and return shader as host object
+      auto shader = getObject()->makeShader(std::move(uniforms), children.data(),
+                                            children.size(), matrix);
+
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(getUniformCount)
+    {
+      return static_cast<int>(getObject()->uniforms().size());
+    }
+
+    JSI_HOST_FUNCTION(getUniformFloatCount)
+    {
+      return static_cast<int>(getObject()->uniformSize() / sizeof(float));
+    }
+
+    JSI_HOST_FUNCTION(getUniformName)
+    {
+      auto i = static_cast<int>(arguments[0].asNumber());
+      if (i < 0 || i >= getObject()->uniforms().size()) {
+        jsi::detail::throwJSError(runtime, "invalid uniform index");
+      }
+      auto it = getObject()->uniforms().begin() + i;
+      return jsi::String::createFromAscii(runtime, it->name.c_str());
+    }
+
+    JSI_HOST_FUNCTION(getUniform)
+    {
+      auto i = static_cast<int>(arguments[0].asNumber());
+      if (i < 0 || i >= getObject()->uniforms().size()) {
+        jsi::detail::throwJSError(runtime, "invalid uniform index");
+      }
+      auto it = getObject()->uniforms().begin() + i;
+      auto result = jsi::Object(runtime);
+      RuntimeEffectUniform su = fromUniform(*it);
+      result.setProperty(runtime, "columns", su.columns);
+      result.setProperty(runtime, "rows", su.rows);
+      result.setProperty(runtime, "slot", su.slot);
+      result.setProperty(runtime, "isInteger", su.isInteger);
+      return result;
+    }
+
+    JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffect, makeShader),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
+                                         makeShaderWithChildren),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformCount),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
+                                         getUniformFloatCount),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformName),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniform))
+
+    JsiSkRuntimeEffect(std::shared_ptr<RNSkPlatformContext> context,
+                       sk_sp<SkRuntimeEffect> rt)
+        : JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>(std::move(context), std::move(rt)){}
+
+  private:
+    sk_sp<SkData> castUniforms(jsi::Runtime &runtime, const jsi::Value &value)
+    {
+      auto jsiUniforms = value.asObject(runtime).asArray(runtime);
+      auto jsiUniformsSize = jsiUniforms.size(runtime);
+
+      // verify size of input uniforms
+      if (jsiUniformsSize * sizeof(float) != getObject()->uniformSize())
+      {
+        std::string msg = "Uniforms size differs from effect's uniform size. Received " +
+                std::to_string(jsiUniformsSize) +
+                " expected " +
+                std::to_string(getObject()->uniformSize() / sizeof(float));
+        jsi::detail::throwJSError(runtime, msg.c_str());
+      }
+
+      auto uniforms = SkData::MakeUninitialized(getObject()->uniformSize());
+
+      // Convert to skia uniforms
+      const auto& u = getObject()->uniforms();
+      for (std::size_t i = 0; i < u.size(); i++)
+      {
+        auto it = getObject()->uniforms().begin() + i;
+        RuntimeEffectUniform reu = fromUniform(*it);
+        for (std::size_t j = 0; j < reu.columns * reu.rows; ++j) {
+          const std::size_t offset = reu.slot + j;
+          float fValue = jsiUniforms.getValueAtIndex(runtime, offset).asNumber();
+          int iValue = static_cast<int>(fValue);
+          auto value = reu.isInteger ? iValue : fValue;
+          memcpy(SkTAddOffset<void>(uniforms->writable_data(), offset * sizeof(value)), &value, sizeof(value));
+        }
+      }
+      return uniforms;
+    }
+
+    RuntimeEffectUniform fromUniform(const SkRuntimeEffect::Uniform &u)
+    {
+      RuntimeEffectUniform su;
+      su.rows = u.count; // arrayLength
+      su.columns = 1;
+      su.isInteger = false;
+      using Type = SkRuntimeEffect::Uniform::Type;
+      switch (u.type)
+      {
+      case Type::kFloat:
+        break;
+      case Type::kFloat2:
+        su.columns = 2;
+        break;
+      case Type::kFloat3:
+        su.columns = 3;
+        break;
+      case Type::kFloat4:
+        su.columns = 4;
+        break;
+      case Type::kFloat2x2:
+        su.columns = 2;
+        su.rows *= 2;
+        break;
+      case Type::kFloat3x3:
+        su.columns = 3;
+        su.rows *= 3;
+        break;
+      case Type::kFloat4x4:
+        su.columns = 4;
+        su.rows *= 4;
+        break;
+      case Type::kInt:
+        su.isInteger = true;
+        break;
+      case Type::kInt2:
+        su.columns = 2;
+        su.isInteger = true;
+        break;
+      case Type::kInt3:
+        su.columns = 3;
+        su.isInteger = true;
+        break;
+      case Type::kInt4:
+        su.columns = 4;
+        su.isInteger = true;
+        break;
+      }
+      su.slot = (int)(u.offset / sizeof(float));
+      return su;
+    }
+
+  };
+} // namespace RNSkia

package/cpp/api/JsiSkRuntimeEffectFactory.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkRuntimeEffect.h"
+#include "JsiSkHostObjects.h"
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRuntimeEffectFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    auto sksl = arguments[0].asString(runtime).utf8(runtime);
+    auto result = SkRuntimeEffect::MakeForShader(SkString(sksl));
+    auto effect = result.effect;
+    auto errorText = result.errorText;
+    if (!effect) {
+      jsi::detail::throwJSError(
+          runtime,
+          std::string("Error in sksl:\n" + std::string(errorText.c_str()))
+              .c_str());
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRuntimeEffect>(getContext(), std::move(effect)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkRuntimeEffectFactory, Make)
+  )
+
+  JsiSkRuntimeEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "JsiSkRuntimeEffect.h"
+#include <SkRuntimeEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkRuntimeShaderBuilder : public JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder> {
+    public:
+       
+        /**
+         Constructor
+         */
+        JsiSkRuntimeShaderBuilder(std::shared_ptr<RNSkPlatformContext> context, const SkRuntimeShaderBuilder &rt)
+                : JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder>(
+                std::move(context), std::make_shared<SkRuntimeShaderBuilder>(rt)){}
+
+        JSI_HOST_FUNCTION(setUniform) {
+            auto name = arguments[0].asString(runtime).utf8(runtime);
+            auto jsiValue = arguments[1].asObject(runtime).asArray(runtime);
+            auto size = jsiValue.size(runtime);
+            std::vector<SkScalar> value;
+            value.reserve(size);
+            for (int i = 0; i < size; i++) {
+                auto e = jsiValue.getValueAtIndex(runtime, i).asNumber();
+                value.push_back(e);
+            }
+            getObject()->uniform(name.c_str()).set(value.data(), static_cast<int>(size));
+            return jsi::Value::undefined();
+        }
+
+        JSI_EXPORT_FUNCTIONS(
+            JSI_EXPORT_FUNC(JsiSkRuntimeShaderBuilder, setUniform)
+        )
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static std::shared_ptr<SkRuntimeShaderBuilder> fromValue(jsi::Runtime &runtime,
+                                                 const jsi::Value &obj) {
+            const auto& object = obj.asObject(runtime);
+            return object.asHostObject<JsiSkRuntimeShaderBuilder>(runtime)->getObject();
+           
+        }
+
+        /**
+          Returns the jsi object from a host object of this type
+         */
+        static jsi::Value toValue(jsi::Runtime &runtime,
+                                  std::shared_ptr<RNSkPlatformContext> context,
+                                  const SkRuntimeShaderBuilder &rt) {
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), rt));
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkRect
+         * wrapper
+         * @param context platform context
+         * @return A function for creating a new host object wrapper for the SkRect
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+            return JSI_HOST_FUNCTION_LAMBDA {
+                auto rt = JsiSkRuntimeEffect::fromValue(runtime, arguments[0]);
+                auto rtb = SkRuntimeShaderBuilder(rt);
+                // Return the newly constructed object
+                return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), std::move(rtb)));
+            };
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkSVG.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkHostObjects.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <modules/svg/include/SkSVGDOM.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkSVG : public JsiSkWrappingSkPtrHostObject<SkSVGDOM> {
+public:
+  JsiSkSVG(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkSVGDOM> svgdom)
+      : JsiSkWrappingSkPtrHostObject<SkSVGDOM>(std::move(context), std::move(svgdom)){}
+
+  JSI_PROPERTY_GET(__typename__) {
+    return jsi::String::createFromUtf8(runtime, "SVG");
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkSVG, __typename__))
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkSVGDOM> fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkSVG>(runtime)
+        ->getObject();
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSVGFactory.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkTypeface.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkData.h"
+#include "JsiSkSVG.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkStream.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkSVGFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(MakeFromData) {
+            auto data = JsiSkData::fromValue(runtime, arguments[0]);
+            auto stream = SkMemoryStream::Make(data);
+            auto svg_dom = SkSVGDOM::Builder().make(*stream);
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+        }
+
+        JSI_HOST_FUNCTION(MakeFromString) {
+            auto svgText = arguments[0].asString(runtime).utf8(runtime);
+            auto stream = SkMemoryStream::MakeDirect(svgText.c_str(), svgText.size());
+            auto svg_dom = SkSVGDOM::Builder().make(*stream);
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+        }
+
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromData), JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromString))
+
+        JsiSkSVGFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia