@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/rnskia/dom/nodes/JsiBlurMaskNode.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "JsiDomDeclarationNode.h"
+
+#include "NodeProp.h"
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkMaskFilter.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class JsiBlurMaskNode : public JsiBaseDomDeclarationNode,
+                        public JsiDomNodeCtor<JsiBlurMaskNode> {
+public:
+  explicit JsiBlurMaskNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseDomDeclarationNode(context, "skBlurMaskFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (context->isChanged() || getPropsContainer()->isChanged()) {
+
+      bool respectCTM =
+          _respectCTM->isSet() ? _respectCTM->value().getAsBool() : true;
+      SkBlurStyle style = SkBlurStyle::kNormal_SkBlurStyle;
+      if (_style->isSet()) {
+        style = getBlurStyleFromString(_style->value().getAsString());
+      }
+
+      auto filter = SkMaskFilter::MakeBlur(style, _blur->value().getAsNumber(),
+                                           respectCTM);
+
+      // Set the mask filter
+      context->getMutablePaint()->setMaskFilter(filter);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _style = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("style")));
+    _respectCTM = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("respectCTM")));
+    _blur = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("blur")));
+
+    _blur->require();
+  }
+
+private:
+  SkBlurStyle getBlurStyleFromString(const std::string &value) {
+    if (value == "normal") {
+      return SkBlurStyle::kNormal_SkBlurStyle;
+    } else if (value == "solid") {
+      return SkBlurStyle::kSolid_SkBlurStyle;
+    } else if (value == "outer") {
+      return SkBlurStyle::kOuter_SkBlurStyle;
+    } else if (value == "inner") {
+      return SkBlurStyle::kInner_SkBlurStyle;
+    }
+    getContext()->raiseError(std::runtime_error(
+        "The value \"" + value + "\" is not " + "a valid blur style."));
+    return SkBlurStyle::kNormal_SkBlurStyle;
+  }
+
+  NodeProp *_style;
+  NodeProp *_respectCTM;
+  NodeProp *_blur;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiBoxNode.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "JsiBoxShadowNode.h"
+#include "JsiDomRenderNode.h"
+
+#include <memory>
+#include <vector>
+
+namespace RNSkia {
+
+class JsiBoxNode : public JsiDomRenderNode, public JsiDomNodeCtor<JsiBoxNode> {
+public:
+  explicit JsiBoxNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomRenderNode(context, "skBox") {}
+
+protected:
+  void renderNode(DrawingContext *context) override {
+    // Verify
+    if (!_rrectProp->isSet() && !_rectProp->isSet()) {
+      throw std::runtime_error("The box property must be set on the Box node.");
+    }
+
+    // Get rect - we'll try to end up with an rrect:
+    auto box = _rrectProp->isSet()
+                   ? *_rrectProp->getDerivedValue()
+                   : SkRRect::MakeRectXY(*_rectProp->getDerivedValue(), 0, 0);
+
+    // Get shadows
+    std::vector<std::shared_ptr<JsiBoxShadowNode>> shadows;
+    for (auto &child : getChildren()) {
+      auto shadowNode = std::dynamic_pointer_cast<JsiBoxShadowNode>(child);
+      if (shadowNode != nullptr && shadowNode->getBoxShadowProps()->isSet()) {
+        shadows.push_back(shadowNode);
+      }
+    }
+    // Render outer shadows
+    for (auto &shadow : shadows) {
+      if (!shadow->getBoxShadowProps()->isInner()) {
+        // Now let's render
+        auto dx = shadow->getBoxShadowProps()->getDx();
+        auto dy = shadow->getBoxShadowProps()->getDy();
+        auto spread = shadow->getBoxShadowProps()->getSpread();
+
+        context->getCanvas()->drawRRect(
+            inflate(box, spread, spread, dx, dy),
+            *shadow->getBoxShadowProps()->getDerivedValue());
+      }
+    }
+
+    // Render box
+    context->getCanvas()->drawRRect(box, *context->getPaint());
+
+    // Render inner shadows
+    for (auto &shadow : shadows) {
+      if (shadow->getBoxShadowProps()->isInner()) {
+        // Now let's render
+        auto dx = shadow->getBoxShadowProps()->getDx();
+        auto dy = shadow->getBoxShadowProps()->getDy();
+        auto spread = shadow->getBoxShadowProps()->getSpread();
+        auto delta = SkPoint::Make(10 + std::abs(dx), 10 + std::abs(dy));
+
+        context->getCanvas()->save();
+        context->getCanvas()->clipRRect(box, SkClipOp::kIntersect, false);
+
+        auto inner = deflate(box, spread, spread, dx, dy);
+        auto outer = inflate(box, delta.x(), delta.y());
+
+        // Render!
+        context->getCanvas()->drawDRRect(
+            outer, inner, *shadow->getBoxShadowProps()->getDerivedValue());
+
+        context->getCanvas()->restore();
+      }
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomRenderNode::defineProperties(container);
+    _rrectProp = container->defineProperty(
+        std::make_shared<RRectProp>(JsiPropId::get("box")));
+    _rectProp = container->defineProperty(
+        std::make_shared<RectProp>(JsiPropId::get("box")));
+  }
+
+private:
+  SkRRect inflate(const SkRRect &box, SkScalar dx, SkScalar dy, size_t tx = 0,
+                  size_t ty = 0) {
+    return SkRRect::MakeRectXY(
+        SkRect::MakeXYWH(box.rect().x() - dx + tx, box.rect().y() - dy + ty,
+                         box.rect().width() + 2 * dx,
+                         box.rect().height() + 2 * dy),
+        box.getSimpleRadii().x() + dx, box.getSimpleRadii().y() + dy);
+  }
+
+  SkRRect deflate(const SkRRect &box, SkScalar dx, SkScalar dy, size_t tx = 0,
+                  size_t ty = 0) {
+    return inflate(box, -dx, -dy, tx, ty);
+  }
+
+  RRectProp *_rrectProp;
+  RectProp *_rectProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiBoxShadowNode.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "BoxShadowProps.h"
+#include "JsiDomDeclarationNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiBoxShadowNode : public JsiBaseDomDeclarationNode,
+                         public JsiDomNodeCtor<JsiBoxShadowNode> {
+public:
+  explicit JsiBoxShadowNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseDomDeclarationNode(context, "skBoxShadow") {}
+
+  BoxShadowProps *getBoxShadowProps() { return _boxShadowProps; }
+
+protected:
+  void decorate(DrawingContext *context) override {
+    // Do nothing, we are just a container for properties
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _boxShadowProps =
+        container->defineProperty(std::make_shared<BoxShadowProps>());
+  }
+
+private:
+  BoxShadowProps *_boxShadowProps;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiCircleNode.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "CircleProp.h"
+#include "JsiDomDrawingNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiCircleNode : public JsiDomDrawingNode,
+                      public JsiDomNodeCtor<JsiCircleNode> {
+public:
+  explicit JsiCircleNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skCircle") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto circle = _circleProp->getDerivedValue();
+    auto r = _radiusProp->value().getAsNumber();
+    context->getCanvas()->drawCircle(*circle, r, *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _circleProp = container->defineProperty(std::make_shared<CircleProp>());
+    _radiusProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameR));
+
+    _circleProp->require();
+    _radiusProp->require();
+  }
+
+private:
+  CircleProp *_circleProp;
+  NodeProp *_radiusProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiColorFilterNodes.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include "JsiDomDeclarationNode.h"
+
+#include "BlendModeProp.h"
+#include "ColorProp.h"
+#include "NodeProp.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkColorFilter.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class JsiBaseColorFilterNode
+    : public JsiDomDeclarationNode<JsiBaseColorFilterNode,
+                                   sk_sp<SkColorFilter>> {
+public:
+  JsiBaseColorFilterNode(std::shared_ptr<RNSkPlatformContext> context,
+                         const char *type)
+      : JsiDomDeclarationNode<JsiBaseColorFilterNode, sk_sp<SkColorFilter>>(
+            context, type) {}
+
+protected:
+  sk_sp<SkColorFilter> resolve(std::shared_ptr<JsiDomNode> child) override {
+    auto ptr = std::dynamic_pointer_cast<JsiBaseColorFilterNode>(child);
+    if (ptr) {
+      return ptr->getCurrent();
+    }
+    return nullptr;
+  }
+
+  void setColorFilter(DrawingContext *context, sk_sp<SkColorFilter> f) {
+    set(context, f);
+  }
+
+  void set(DrawingContext *context, sk_sp<SkColorFilter> ColorFilter) override {
+    auto paint = context->getMutablePaint();
+    if (paint->getColorFilter() != nullptr &&
+        paint->getColorFilter() != getCurrent().get()) {
+      paint->setColorFilter(
+          SkColorFilters::Compose(paint->refColorFilter(), ColorFilter));
+    } else {
+      paint->setColorFilter(ColorFilter);
+    }
+
+    setCurrent(ColorFilter);
+  }
+};
+
+class JsiMatrixColorFilterNode
+    : public JsiBaseColorFilterNode,
+      public JsiDomNodeCtor<JsiMatrixColorFilterNode> {
+public:
+  explicit JsiMatrixColorFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skMatrixColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto array = _matrixProp->value().getAsArray();
+      float matrix[20];
+      for (int i = 0; i < 20; i++) {
+        if (array.size() > i) {
+          matrix[i] = array[i].getAsNumber();
+        }
+      }
+      setColorFilter(context, SkColorFilters::Matrix(matrix));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _matrixProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("matrix")));
+    _matrixProp->require();
+  }
+
+private:
+  NodeProp *_matrixProp;
+};
+
+class JsiBlendColorFilterNode : public JsiBaseColorFilterNode,
+                                public JsiDomNodeCtor<JsiBlendColorFilterNode> {
+public:
+  explicit JsiBlendColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skBlendColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      setColorFilter(context,
+                     SkColorFilters::Blend(*_colorProp->getDerivedValue(),
+                                           *_blendModeProp->getDerivedValue()));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _blendModeProp = container->defineProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("mode")));
+    _colorProp = container->defineProperty(
+        std::make_shared<ColorProp>(JsiPropId::get("color")));
+
+    _blendModeProp->require();
+    _colorProp->require();
+  }
+
+private:
+  BlendModeProp *_blendModeProp;
+  ColorProp *_colorProp;
+};
+
+class JsiLinearToSRGBGammaColorFilterNode
+    : public JsiBaseColorFilterNode,
+      public JsiDomNodeCtor<JsiLinearToSRGBGammaColorFilterNode> {
+public:
+  explicit JsiLinearToSRGBGammaColorFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skLinearToSRGBGammaColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      setColorFilter(context, SkColorFilters::LinearToSRGBGamma());
+    }
+  }
+};
+
+class JsiSRGBToLinearGammaColorFilterNode
+    : public JsiBaseColorFilterNode,
+      public JsiDomNodeCtor<JsiSRGBToLinearGammaColorFilterNode> {
+public:
+  explicit JsiSRGBToLinearGammaColorFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skSRGBToLinearGammaColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      setColorFilter(context, SkColorFilters::SRGBToLinearGamma());
+    }
+  }
+};
+
+class JsiLumaColorFilterNode : public JsiBaseColorFilterNode,
+                               public JsiDomNodeCtor<JsiLumaColorFilterNode> {
+public:
+  explicit JsiLumaColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skLumaColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      setColorFilter(context, SkLumaColorFilter::Make());
+    }
+  }
+};
+
+class JsiLerpColorFilterNode : public JsiBaseColorFilterNode,
+                               public JsiDomNodeCtor<JsiLerpColorFilterNode> {
+public:
+  explicit JsiLerpColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseColorFilterNode(context, "skLerpColorFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      setColorFilter(context,
+                     SkColorFilters::Lerp(_tProp->value().getAsNumber(),
+                                          requireChild(0), requireChild(1)));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _tProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("t")));
+    _tProp->require();
+  }
+
+private:
+  NodeProp *_tProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiCustomDrawingNode.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include "DrawingProp.h"
+#include "JsiDomDrawingNode.h"
+
+#include "JsiSkCanvas.h"
+#include "JsiSkPaint.h"
+
+#include <memory>
+#include <utility>
+
+namespace RNSkia {
+
+class JsiCustomDrawingNode : public JsiDomDrawingNode,
+                             public JsiDomNodeCtor<JsiCustomDrawingNode> {
+public:
+  explicit JsiCustomDrawingNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skCustomDrawing") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    if (_drawing != nullptr) {
+
+      // Only repaint the picture IF we did not get to the draw function
+      // from a redrawRequest after creating the picture!
+      if (!_inRedrawCycle || _drawingProp->isChanged()) {
+
+        float scaledWidth = context->getScaledWidth();
+        float scaledHeight = context->getScaledHeight();
+        auto paint = context->getPaint();
+        auto opacity = context->getOpacity();
+        auto platformContext = getContext();
+        auto requestRedraw = context->getRequestRedraw();
+
+        // Create/set the paint/canvas wrappers
+        if (_jsiPaint == nullptr) {
+          _jsiPaint = std::make_shared<JsiSkPaint>(getContext(), *paint);
+        } else {
+          _jsiPaint->fromPaint(*paint);
+        }
+
+        if (_jsiCanvas == nullptr) {
+          _jsiCanvas = std::make_shared<JsiSkCanvas>(getContext());
+        }
+
+        // Run rendering on the javascript thread
+        getContext()->runOnJavascriptThread([this, platformContext, opacity,
+                                             requestRedraw, scaledWidth,
+                                             scaledHeight]() {
+          // Get the runtime
+          auto runtime = platformContext->getJsRuntime();
+
+          // Create the picture recorder
+          SkPictureRecorder recorder;
+          SkRTreeFactory factory;
+          SkCanvas *canvas =
+              recorder.beginRecording(scaledWidth, scaledHeight, &factory);
+
+          auto jsiCanvas =
+              std::make_shared<JsiSkCanvas>(platformContext, canvas);
+
+          // Create context wrapper
+          auto jsiCtx = jsi::Object(*runtime);
+          jsiCtx.setProperty(
+              *runtime, "paint",
+              jsi::Object::createFromHostObject(*runtime, this->_jsiPaint));
+
+          jsiCtx.setProperty(*runtime, "opacity", opacity);
+          jsiCtx.setProperty(
+              *runtime, "canvas",
+              jsi::Object::createFromHostObject(*runtime, jsiCanvas));
+
+          std::array<jsi::Value, 1> args;
+          args[0] = std::move(jsiCtx);
+
+          // Draw
+          _drawing(*runtime, jsi::Value::undefined(),
+                   static_cast<const jsi::Value *>(args.data()), 1);
+
+          auto picture = recorder.finishRecordingAsPicture();
+          this->_drawingProp->setPicture(picture);
+
+          // Ask view to redraw itself
+          _inRedrawCycle = true;
+          requestRedraw();
+        });
+      }
+    }
+
+    if (_drawingProp->isSet()) {
+      context->getCanvas()->drawPicture(_drawingProp->getDerivedValue());
+      _inRedrawCycle = false;
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+
+    NotifyNeedRenderCallback cb =
+        std::bind(&JsiCustomDrawingNode::notifyPictureNeeded, this,
+                  std::placeholders::_1);
+
+    _drawingProp = container->defineProperty(
+        std::make_shared<DrawingProp>(JsiPropId::get("drawing"), cb));
+  }
+
+private:
+  void notifyPictureNeeded(jsi::HostFunctionType drawing) {
+    _drawing = drawing;
+  }
+
+  jsi::HostFunctionType _drawing;
+
+  DrawingProp *_drawingProp;
+
+  std::array<jsi::Value, 1> _argsCache;
+  std::shared_ptr<JsiSkPaint> _jsiPaint;
+  std::shared_ptr<JsiSkCanvas> _jsiCanvas;
+
+  std::atomic<bool> _inRedrawCycle = {false};
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiDiffRectNode.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "RRectProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+static PropId PropNameInner = JsiPropId::get("inner");
+static PropId PropNameOuter = JsiPropId::get("outer");
+
+class JsiDiffRectNode : public JsiDomDrawingNode,
+                        public JsiDomNodeCtor<JsiDiffRectNode> {
+public:
+  explicit JsiDiffRectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skDiffRect") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    context->getCanvas()->drawDRRect(*_outerRectProp->getDerivedValue(),
+                                     *_innerRectProp->getDerivedValue(),
+                                     *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _innerRectProp =
+        container->defineProperty(std::make_shared<RRectProp>(PropNameInner));
+    _outerRectProp =
+        container->defineProperty(std::make_shared<RRectProp>(PropNameOuter));
+
+    _innerRectProp->require();
+    _outerRectProp->require();
+  }
+
+private:
+  RRectProp *_innerRectProp;
+  RRectProp *_outerRectProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiFillNode.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "RectProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiFillNode : public JsiDomDrawingNode,
+                    public JsiDomNodeCtor<JsiFillNode> {
+public:
+  explicit JsiFillNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skFill") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    context->getCanvas()->drawPaint(*context->getPaint());
+  }
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiGlyphsNode.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+
+#include "FontProp.h"
+#include "GlyphsProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiGlyphsNode : public JsiDomDrawingNode,
+                      public JsiDomNodeCtor<JsiGlyphsNode> {
+public:
+  explicit JsiGlyphsNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skGlyphs") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto x = _xProp->value().getAsNumber();
+    auto y = _yProp->value().getAsNumber();
+    auto font = _fontProp->getDerivedValue();
+    auto glyphInfo = _glyphsProp->getDerivedValue();
+
+    context->getCanvas()->drawGlyphs(
+        static_cast<int>(glyphInfo->glyphIds.size()),
+        glyphInfo->glyphIds.data(), glyphInfo->positions.data(),
+        SkPoint::Make(x, y), *font, *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+
+    _fontProp = container->defineProperty(
+        std::make_shared<FontProp>(JsiPropId::get("font")));
+    _glyphsProp = container->defineProperty(
+        std::make_shared<GlyphsProp>(JsiPropId::get("glyphs")));
+    _xProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("x")));
+    _yProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("y")));
+
+    _fontProp->require();
+    _glyphsProp->require();
+    _xProp->require();
+    _yProp->require();
+  }
+
+private:
+  FontProp *_fontProp;
+  GlyphsProp *_glyphsProp;
+  NodeProp *_xProp;
+  NodeProp *_yProp;
+};
+
+} // namespace RNSkia