@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkFont.h

@@ -0,0 +1,326 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkPaint.h"
+#include "JsiSkRect.h"
+#include "JsiSkTypeface.h"
+#include "JsiSkPoint.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkFont.h>
+#include <SkFontMetrics.h>
+
+#pragma clang diagnostic pop
+
+
+namespace RNSkia
+{
+
+    using namespace facebook;
+
+    class JsiSkFont : public JsiSkWrappingSharedPtrHostObject<SkFont>
+    {
+    public:
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+        JSI_PROPERTY_GET(__typename__)
+        {
+            return jsi::String::createFromUtf8(runtime, "Font");
+        }
+
+        JSI_HOST_FUNCTION(measureText)
+        {
+            auto textVal = arguments[0].asString(runtime).utf8(runtime);
+            auto text = textVal.c_str();
+            SkRect rect;
+            std::shared_ptr<SkPaint> paint = nullptr;
+            // Check if a paint argument was provided
+            if (count == 2)
+            {
+                paint = JsiSkPaint::fromValue(runtime, arguments[1]);
+            }
+            getObject()->measureText(text, strlen(text), SkTextEncoding::kUTF8, &rect,
+                                     paint.get());
+            rect.setXYWH(0, 0, rect.width(), rect.height());
+            return JsiSkRect::toValue(runtime, getContext(), std::move(rect));
+        }
+
+        JSI_HOST_FUNCTION(getGlyphWidths)
+        {
+            auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+            std::vector<SkGlyphID> glyphs;
+            int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+
+            std::vector<SkScalar> widthPtrs;
+            widthPtrs.resize(glyphsSize);
+
+            glyphs.reserve(glyphsSize);
+            for (int i = 0; i < glyphsSize; i++)
+            {
+                glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
+            }
+            if (count > 1)
+            {
+                auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
+                getObject()->getWidthsBounds(glyphs.data(), glyphsSize, static_cast<SkScalar *>(widthPtrs.data()), nullptr, paint.get());
+            }
+            else
+            {
+                getObject()->getWidthsBounds(glyphs.data(), glyphsSize, static_cast<SkScalar *>(widthPtrs.data()), nullptr, nullptr);
+            }
+            auto jsiWidths = jsi::Array(runtime, glyphsSize);
+            for (int i = 0; i < glyphsSize; i++)
+            {
+                jsiWidths.setValueAtIndex(runtime, i, jsi::Value(SkScalarToDouble(static_cast<SkScalar *>(widthPtrs.data())[i])));
+            }
+            return jsiWidths;
+        }
+
+        JSI_HOST_FUNCTION(getMetrics)
+        {
+            SkFontMetrics fm;
+            getObject()->getMetrics(&fm);
+            auto metrics = jsi::Object(runtime);
+            metrics.setProperty(runtime, "ascent", fm.fAscent);
+            metrics.setProperty(runtime, "descent", fm.fDescent);
+            metrics.setProperty(runtime, "leading", fm.fLeading);
+            if (!(fm.fFlags & SkFontMetrics::kBoundsInvalid_Flag))
+            {
+                auto bounds = SkRect::MakeLTRB(fm.fXMin, fm.fTop, fm.fXMax, fm.fBottom);
+                auto jsiBounds = JsiSkRect::toValue(runtime, getContext(), std::move(bounds));
+                metrics.setProperty(runtime, "bounds", std::move(jsiBounds));
+            }
+            return metrics;
+        }
+
+        JSI_HOST_FUNCTION(getGlyphIDs)
+        {
+            auto str = arguments[0].asString(runtime).utf8(runtime);
+            auto numGlyphIDs = count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
+                                   ? arguments[1].asNumber()
+                                   : str.length();
+            std::vector<SkGlyphID> glyphIDs;
+            glyphIDs.resize(numGlyphIDs);
+            getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
+                                      static_cast<SkGlyphID *>(glyphIDs.data()), numGlyphIDs);
+            auto jsiGlyphIDs = jsi::Array(runtime, numGlyphIDs);
+            for (int i = 0; i < numGlyphIDs; i++)
+            {
+                jsiGlyphIDs.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(glyphIDs[i])));
+            }
+            return jsiGlyphIDs;
+        }
+
+        JSI_HOST_FUNCTION(getGlyphIntercepts)
+        {
+            auto jsiGlyphs = arguments[0].asObject(runtime).asArray(runtime);
+            auto jsiPositions = arguments[1].asObject(runtime).asArray(runtime);
+            auto top = arguments[2].asNumber();
+            auto bottom = arguments[3].asNumber();
+            std::vector<SkPoint> positions;
+            int pointsSize = static_cast<int>(jsiPositions.size(runtime));
+            positions.reserve(pointsSize);
+            for (int i = 0; i < pointsSize; i++)
+            {
+                std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
+                    runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
+                positions.push_back(*point.get());
+            }
+
+            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());
+            }
+
+            if (glyphs.size() > positions.size())
+            {
+                jsi::detail::throwJSError(runtime, "Not enough x,y position pairs for glyphs");
+                return jsi::Value::null();
+            }
+            auto sects = getObject()->getIntercepts(glyphs.data(), SkToInt(glyphs.size()), positions.data(), top, bottom);
+            auto jsiSects = jsi::Array(runtime, sects.size());
+            for (int i = 0; i < sects.size(); i++)
+            {
+                jsiSects.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(sects.at(i))));
+            }
+            return jsiSects;
+        }
+
+        JSI_HOST_FUNCTION(getScaleX)
+        {
+            return jsi::Value(SkScalarToDouble(getObject()->getScaleX()));
+        }
+
+        JSI_HOST_FUNCTION(getSize)
+        {
+            return jsi::Value(SkScalarToDouble(getObject()->getSize()));
+        }
+
+        JSI_HOST_FUNCTION(getSkewX)
+        {
+            return jsi::Value(SkScalarToDouble(getObject()->getSkewX()));
+        }
+
+        JSI_HOST_FUNCTION(isEmbolden)
+        {
+            return jsi::Value(getObject()->isEmbolden());
+        }
+
+        JSI_HOST_FUNCTION(getTypeface)
+        {
+            return JsiSkTypeface::toValue(runtime, getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
+        }
+
+        JSI_HOST_FUNCTION(setEdging)
+        {
+            auto edging = arguments[0].asNumber();
+            getObject()->setEdging(static_cast<SkFont::Edging>(edging));
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(embeddedBitmaps)
+        {
+            auto embeddedBitmaps = arguments[0].getBool();
+            getObject()->setEmbeddedBitmaps(embeddedBitmaps);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setHinting)
+        {
+            auto hinting = arguments[0].asNumber();
+            getObject()->setHinting(static_cast<SkFontHinting>(hinting));
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setLinearMetrics)
+        {
+            auto linearMetrics = arguments[0].getBool();
+            getObject()->setLinearMetrics(linearMetrics);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setScaleX)
+        {
+            auto scaleX = arguments[0].asNumber();
+            getObject()->setScaleX(scaleX);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setSkewX)
+        {
+            auto skewX = arguments[0].asNumber();
+            getObject()->setSkewX(skewX);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setSize)
+        {
+            auto size = arguments[0].asNumber();
+            getObject()->setSize(size);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setEmbolden)
+        {
+            auto embolden = arguments[0].asNumber();
+            getObject()->setEmbolden(embolden);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setSubpixel)
+        {
+            auto subpixel = arguments[0].asNumber();
+            getObject()->setSubpixel(subpixel);
+            return jsi::Value::undefined();
+        }
+
+        JSI_HOST_FUNCTION(setTypeface)
+        {
+            auto typeface = arguments[0].isNull() ? nullptr : JsiSkTypeface::fromValue(runtime, arguments[0]);
+            getObject()->setTypeface(typeface);
+            return jsi::Value::undefined();
+        }
+
+        JSI_EXPORT_FUNCTIONS(
+            JSI_EXPORT_FUNC(JsiSkFont, measureText),
+            JSI_EXPORT_FUNC(JsiSkFont, getMetrics),
+            JSI_EXPORT_FUNC(JsiSkFont, getGlyphIDs),
+            JSI_EXPORT_FUNC(JsiSkFont, getGlyphIntercepts),
+            JSI_EXPORT_FUNC(JsiSkFont, getScaleX),
+            JSI_EXPORT_FUNC(JsiSkFont, getSkewX),
+            JSI_EXPORT_FUNC(JsiSkFont, getTypeface),
+            JSI_EXPORT_FUNC(JsiSkFont, setEdging),
+            JSI_EXPORT_FUNC(JsiSkFont, embeddedBitmaps),
+            JSI_EXPORT_FUNC(JsiSkFont, setHinting),
+            JSI_EXPORT_FUNC(JsiSkFont, setLinearMetrics),
+            JSI_EXPORT_FUNC(JsiSkFont, setScaleX),
+            JSI_EXPORT_FUNC(JsiSkFont, setSkewX),
+            JSI_EXPORT_FUNC(JsiSkFont, setSize),
+            JSI_EXPORT_FUNC(JsiSkFont, setEmbolden),
+            JSI_EXPORT_FUNC(JsiSkFont, setSubpixel),
+            JSI_EXPORT_FUNC(JsiSkFont, setTypeface),
+            JSI_EXPORT_FUNC(JsiSkFont, getGlyphWidths))
+
+        JsiSkFont(std::shared_ptr<RNSkPlatformContext> context, const SkFont &font)
+            : JsiSkWrappingSharedPtrHostObject(std::move(context),
+                                               std::make_shared<SkFont>(font)){}
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static std::shared_ptr<SkFont> fromValue(jsi::Runtime &runtime,
+                                                 const jsi::Value &obj)
+        {
+            return obj.asObject(runtime)
+                .asHostObject<JsiSkFont>(runtime)
+                ->getObject();
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkFont
+         * wrapper
+         * @param context Platform context
+         * @return A function for creating a new host object wrapper for the SkFont
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context)
+        {
+            return JSI_HOST_FUNCTION_LAMBDA
+            {
+                // Handle arguments
+                if (count == 2)
+                {
+                    auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
+                    auto size = arguments[1].asNumber();
+                    return jsi::Object::createFromHostObject(
+                        runtime,
+                        std::make_shared<JsiSkFont>(std::move(context), SkFont(typeface, size)));
+                }
+                else if (count == 1)
+                {
+                    auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
+                    return jsi::Object::createFromHostObject(
+                        runtime, std::make_shared<JsiSkFont>(std::move(context), SkFont(typeface)));
+                }
+                else
+                {
+                    // Return the newly constructed object
+                    return jsi::Object::createFromHostObject(
+                        runtime, std::make_shared<JsiSkFont>(std::move(context), SkFont()));
+                }
+            };
+        }
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkFontMgr.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkFont.h>
+#include <SkFontMgr.h>
+#include <SkTypeface.h>
+
+#pragma clang diagnostic pop
+
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkFontMgr : public JsiSkWrappingSkPtrHostObject<SkFontMgr> {
+    public:
+
+        // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+        JSI_PROPERTY_GET(__typename__) {
+            return jsi::String::createFromUtf8(runtime, "FontMgr");
+        }
+
+        JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkFontMgr, __typename__))
+
+        JsiSkFontMgr(std::shared_ptr<RNSkPlatformContext> context,
+                     sk_sp<SkFontMgr> fontMgr)
+                : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(fontMgr)) {}
+
+        JSI_HOST_FUNCTION(countFamilies) {
+            auto families = getObject()->countFamilies();
+            return jsi::Value(families);
+        }
+
+        JSI_HOST_FUNCTION(getFamilyName) {
+            auto i = arguments[0].asNumber();
+            SkString familyName;
+            getObject()->getFamilyName(i, &familyName);
+            return jsi::String::createFromUtf8(runtime, familyName.c_str());
+        }
+
+        JSI_HOST_FUNCTION(matchFamilyStyle) {
+            auto familyName = arguments[0].asString(runtime).utf8(runtime);
+            auto fontStyle = SkFontStyle::Normal();
+            if (count >= 2) {
+                auto object = arguments[1].asObject(runtime);
+                int weight = object.getProperty(runtime, "weight").asNumber();
+                int width = object.getProperty(runtime, "width").asNumber();
+                SkFontStyle::Slant slant = (SkFontStyle::Slant)object.getProperty(runtime, "slant").asNumber();
+                fontStyle = SkFontStyle(width, weight, slant);
+            }
+            auto typeface = getObject()->matchFamilyStyle(familyName.c_str(), std::move(fontStyle));
+            if (typeface == nullptr) {
+                return jsi::Value::null();
+            }
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkTypeface>(getContext(), sk_sp<SkTypeface>(std::move(typeface))));;
+        }
+
+        JSI_EXPORT_FUNCTIONS(
+            JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
+            JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
+            JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle)
+        )
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static sk_sp<SkFontMgr> fromValue(jsi::Runtime &runtime,
+                                           const jsi::Value &obj) {
+            return obj.asObject(runtime)
+                    .asHostObject<JsiSkFontMgr>(runtime)
+                    ->getObject();
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkFontMgrFactory.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "JsiSkFontMgr.h"
+#include "JsiSkData.h"
+#include <SkFontMgr.h>
+
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkFontMgrFactory : public JsiSkHostObject {
+    public:
+//        JSI_HOST_FUNCTION(FromData) {
+//            std::vector<sk_sp<SkData>> data;
+//            for (int i = 0; i < count; i++) {
+//                auto d = JsiSkData::fromValue(
+//                        runtime, arguments[i]);
+//                data.push_back(d);
+//            }
+//
+//            auto fontMgr = SkFontMgr_New_Custom_Data(data.data(), data.size());
+//            return jsi::Object::createFromHostObject(
+//            runtime, std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
+//        }
+
+        JSI_HOST_FUNCTION(RefDefault) {
+            auto fontMgr = SkFontMgr::RefDefault();
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkFontMgr>(getContext(), std::move(fontMgr)));
+        }
+
+        JSI_EXPORT_FUNCTIONS(
+                //JSI_EXPORT_FUNC(JsiSkFontMgrFactory, FromData),
+                JSI_EXPORT_FUNC(JsiSkFontMgrFactory, RefDefault)
+        )
+
+        JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkHostObjects.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "RNSkPlatformContext.h"
+#include <JsiHostObject.h>
+
+namespace RNSkia {
+
+using namespace facebook;
+using namespace RNJsi;
+
+/**
+ * Base class for jsi host objects
+ */
+class JsiSkHostObject : public JsiHostObject {
+public:
+  /**
+   * Default constructor
+   * @param context Platform context
+   */
+  JsiSkHostObject(std::shared_ptr<RNSkPlatformContext> context)
+      : _context(context){};
+
+protected:
+
+  /**
+   * @return A pointer to the platform context
+   */
+  std::shared_ptr<RNSkPlatformContext> getContext() { return _context; }
+
+private:
+  std::shared_ptr<RNSkPlatformContext> _context;
+};
+
+template <typename T> class JsiSkWrappingHostObject : public JsiSkHostObject {
+public:
+  /**
+   * Default constructor
+   * @param context Platform context
+   */
+  JsiSkWrappingHostObject(std::shared_ptr<RNSkPlatformContext> context,
+                          T&& object)
+      : JsiSkHostObject(std::move(context)), _object(std::move(object)){}
+  
+  JsiSkWrappingHostObject(std::shared_ptr<RNSkPlatformContext> context,
+                          const T& object)
+      : JsiSkHostObject(std::move(context)), _object(object){}
+
+  /**
+   * Returns the underlying object exposed by this host object. This object
+   * should be wrapped in a shared pointer of some kind
+   * @return Underlying object
+   */
+  T& getObject() { return _object; }
+  const T& getObject() const { return _object; }
+
+
+private:
+  /**
+   * Wrapped object
+   */
+  T _object;
+};
+
+template <typename T>
+class JsiSkWrappingSharedPtrHostObject
+    : public JsiSkWrappingHostObject<std::shared_ptr<T>> {
+public:
+  JsiSkWrappingSharedPtrHostObject(std::shared_ptr<RNSkPlatformContext> context,
+                                   std::shared_ptr<T> object)
+      : JsiSkWrappingHostObject<std::shared_ptr<T>>(std::move(context), std::move(object)) {}
+};
+
+template <typename T>
+class JsiSkWrappingSkPtrHostObject : public JsiSkWrappingHostObject<sk_sp<T>> {
+public:
+  JsiSkWrappingSkPtrHostObject(std::shared_ptr<RNSkPlatformContext> context,
+                               sk_sp<T> object)
+      : JsiSkWrappingHostObject<sk_sp<T>>(std::move(context), std::move(object)) {}
+};
+} // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -0,0 +1,141 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "JsiSkMatrix.h"
+#include <JsiSkHostObjects.h>
+#include "JsiSkShader.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkBase64.h>
+#include <SkImage.h>
+#include <SkStream.h>
+#include <include/codec/SkCodec.h>
+
+#pragma clang diagnostic pop
+
+#include <jsi/jsi.h>
+
+namespace RNSkia
+{
+
+  using namespace facebook;
+
+  class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage>
+  {
+  public:
+    // 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(makeShaderOptions)
+    {
+      auto tmx = (SkTileMode)arguments[0].asNumber();
+      auto tmy = (SkTileMode)arguments[1].asNumber();
+      auto fm = (SkFilterMode)arguments[2].asNumber();
+      auto mm = (SkMipmapMode)arguments[3].asNumber();
+      auto m = count > 4 && !arguments[4].isUndefined() ? JsiSkMatrix::fromValue(runtime, arguments[4]).get()
+                                                        : nullptr;
+      auto shader =
+          getObject()->makeShader(tmx, tmy, SkSamplingOptions(fm, mm), m);
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(makeShaderCubic)
+    {
+      auto tmx = (SkTileMode)arguments[0].asNumber();
+      auto tmy = (SkTileMode)arguments[1].asNumber();
+      auto B = (float)arguments[2].asNumber();
+      auto C = (float)arguments[3].asNumber();
+      auto m = count > 4 && !arguments[4].isUndefined() ? JsiSkMatrix::fromValue(runtime, arguments[4]).get()
+                                                        : nullptr;
+      auto shader =
+          getObject()->makeShader(tmx, tmy, SkSamplingOptions({B, C}), m);
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(encodeToBytes)
+    {
+      // Get optional parameters
+      auto format = count >= 1 ? getFormatFromNumber(
+        static_cast<int>(arguments[0].asNumber())) : SkEncodedImageFormat::kPNG;
+      
+      auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
+      
+      // Get data
+      auto data = getObject()->encodeToData(format, quality);
+      auto arrayCtor = runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
+      size_t size = data->size();
+
+      jsi::Object array = arrayCtor.callAsConstructor(runtime, static_cast<double>(size)).getObject(runtime);
+      jsi::ArrayBuffer buffer = array
+                                    .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+                                    .asObject(runtime)
+                                    .getArrayBuffer(runtime);
+
+      auto bfrPtr = reinterpret_cast<uint8_t *>(buffer.data(runtime));
+      memcpy(bfrPtr, data->bytes(), size);
+      return array;
+    }
+
+    JSI_HOST_FUNCTION(encodeToBase64)
+    {
+      // Get optional parameters
+      auto format = count >= 1 ? getFormatFromNumber(
+        static_cast<int>(arguments[0].asNumber())) : SkEncodedImageFormat::kPNG;
+      
+      auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
+      
+      auto data = getObject()->encodeToData(format, quality);
+      auto len = SkBase64::Encode(data->bytes(), data->size(), nullptr);
+      auto buffer = std::string(len, 0);
+      SkBase64::Encode(data->bytes(), data->size(), (void *)&buffer[0]);
+      return jsi::String::createFromAscii(runtime, buffer);
+    }
+
+    JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
+                         JSI_EXPORT_FUNC(JsiSkImage, height),
+                         JSI_EXPORT_FUNC(JsiSkImage, makeShaderOptions),
+                         JSI_EXPORT_FUNC(JsiSkImage, makeShaderCubic),
+                         JSI_EXPORT_FUNC(JsiSkImage, encodeToBytes),
+                         JSI_EXPORT_FUNC(JsiSkImage, encodeToBase64))
+
+    JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
+               const sk_sp<SkImage> image)
+        : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context), std::move(image)){}
+
+    /**
+    Returns the underlying object from a host object of this type
+   */
+    static sk_sp<SkImage> fromValue(jsi::Runtime &runtime,
+                                    const jsi::Value &obj)
+    {
+      return obj.asObject(runtime)
+          .asHostObject<JsiSkImage>(runtime)
+          ->getObject();
+    }
+  private:
+    
+    SkEncodedImageFormat getFormatFromNumber(int value) {
+      switch(value) {
+        case 0: // PNG
+          return SkEncodedImageFormat::kPNG;
+        case 1: // JPEG
+          return SkEncodedImageFormat::kJPEG;
+        case 2: // WEBP
+          return SkEncodedImageFormat::kWEBP;
+        default:
+          return SkEncodedImageFormat::kPNG;
+      }
+    }
+  };
+
+} // namespace RNSkia