@shopify/react-native-skia 0.1.221 → 0.1.223

package/cpp/api/JsiSkParagraphBuilder.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkFont.h>
+#include <JsiSkFontMgr.h>
+#include <JsiSkHostObjects.h>
+#include <JsiSkParagraph.h>
+#include <JsiSkParagraphStyle.h>
+#include <JsiSkTextStyle.h>
+#include <JsiSkTypefaceFontProvider.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "ParagraphBuilder.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ Implementation of the ParagraphBuilder object in JSI
+ */
+class JsiSkParagraphBuilder : public JsiSkHostObject {
+public:
+  JSI_API_TYPENAME("ParagraphBuilder");
+
+  JSI_HOST_FUNCTION(build) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkParagraph>(getContext(), _builder.get()));
+  }
+
+  JSI_HOST_FUNCTION(reset) {
+    _builder->Reset();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(addText) {
+    auto text = getArgumentAsString(runtime, arguments, count, 0).utf8(runtime);
+    _builder->addText(text.c_str());
+    return thisValue.asObject(runtime);
+  }
+
+  JSI_HOST_FUNCTION(addPlaceholder) {
+    auto width =
+        count >= 1 ? getArgumentAsNumber(runtime, arguments, count, 0) : 0;
+    auto height =
+        count >= 2 ? getArgumentAsNumber(runtime, arguments, count, 1) : 0;
+    auto alignment =
+        count >= 3 ? static_cast<para::PlaceholderAlignment>(
+                         getArgumentAsNumber(runtime, arguments, count, 2))
+                   : para::PlaceholderAlignment::kBaseline;
+    auto baseline = count >= 4
+                        ? static_cast<para::TextBaseline>(
+                              getArgumentAsNumber(runtime, arguments, count, 3))
+                        : para::TextBaseline::kAlphabetic;
+    auto offset =
+        count >= 5 ? getArgumentAsNumber(runtime, arguments, count, 4) : 0;
+
+    para::PlaceholderStyle style(width, height, alignment, baseline, offset);
+    _builder->addPlaceholder(style);
+
+    return thisValue.asObject(runtime);
+  }
+
+  JSI_HOST_FUNCTION(pushStyle) {
+    auto textStyle = JsiSkTextStyle::fromValue(runtime, arguments[0]);
+    // Foreground paint
+    if (count >= 2) {
+      auto foreground =
+          tryGetArgumentAsHostObject<JsiSkPaint>(runtime, arguments, count, 1);
+      if (foreground) {
+        textStyle.setForegroundPaint(*foreground->getObject().get());
+      }
+    }
+    // Background paint
+    if (count >= 3) {
+      auto background =
+          tryGetArgumentAsHostObject<JsiSkPaint>(runtime, arguments, count, 2);
+      if (background) {
+        textStyle.setBackgroundPaint(*background->getObject().get());
+      }
+    }
+
+    _builder->pushStyle(textStyle);
+
+    return thisValue.asObject(runtime);
+  }
+
+  JSI_HOST_FUNCTION(pop) {
+    _builder->pop();
+    return thisValue.asObject(runtime);
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraphBuilder, build),
+                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, reset),
+                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, addText),
+                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, addPlaceholder),
+                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pushStyle),
+                       JSI_EXPORT_FUNC(JsiSkParagraphBuilder, pop))
+
+  explicit JsiSkParagraphBuilder(std::shared_ptr<RNSkPlatformContext> context,
+                                 para::ParagraphStyle paragraphStyle,
+                                 sk_sp<SkFontMgr> fontManager)
+      : JsiSkHostObject(std::move(context)) {
+    _fontCollection = sk_make_sp<para::FontCollection>();
+    _fontCollection->setDefaultFontManager(getContext()->createFontMgr());
+    if (fontManager != nullptr) {
+      _fontCollection->setAssetFontManager(fontManager);
+    }
+    _fontCollection->enableFontFallback();
+    _builder = para::ParagraphBuilder::make(paragraphStyle, _fontCollection);
+  }
+
+private:
+  std::unique_ptr<para::ParagraphBuilder> _builder;
+  sk_sp<para::FontCollection> _fontCollection;
+};
+
+/**
+ Implementation of the ParagraphBuilderFactory for making ParagraphBuilder JSI
+ object
+ */
+class JsiSkParagraphBuilderFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    // Get paragraph style from params
+    auto paragraphStyle =
+        count > 0 ? JsiSkParagraphStyle::fromValue(runtime, arguments[0])
+                  : para::ParagraphStyle();
+
+    // get font manager
+    auto fontMgr =
+        count > 1 ? JsiSkTypefaceFontProvider::fromValue(runtime, arguments[1])
+                  : nullptr;
+
+    // Create the paragraph builder
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkParagraphBuilder>(
+                     getContext(), paragraphStyle, fontMgr));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraphBuilderFactory, Make))
+
+  explicit JsiSkParagraphBuilderFactory(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkParagraphStyle.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#include <codecvt>
+#include <locale>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkStrutStyle.h>
+#include <JsiSkTextStyle.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "Paragraph.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+/**
+ Implementation of the ParagraphStyle object in JSI
+ */
+class JsiSkParagraphStyle {
+public:
+  /**
+   disableHinting?: boolean;
+   ellipsis?: string;
+   heightMultiplier?: number;
+   maxLines?: number;
+   replaceTabCharacters?: boolean;
+   strutStyle?: SkStrutStyle;
+   textAlign?: SkTextAlign;
+   textDirection?: SkTextDirection;
+   textHeightBehavior?: SkTextHeightBehavior;
+   textStyle?: SkTextStyle;
+   */
+  static para::ParagraphStyle fromValue(jsi::Runtime &runtime,
+                                        const jsi::Value &value) {
+    para::ParagraphStyle retVal;
+
+    // Accept undefined && null
+    if (value.isUndefined() || value.isNull()) {
+      return retVal;
+    }
+
+    // Read values from the argument - expected to be a ParagraphStyle shaped
+    // object
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime, "Expected SkParagrahStyle as first argument");
+    }
+
+    auto object = value.asObject(runtime);
+
+    if (object.hasProperty(runtime, "disableHinting")) {
+      auto propValue = object.getProperty(runtime, "disableHinting");
+      if (propValue.asBool()) {
+        retVal.turnHintingOff();
+      }
+    }
+    if (object.hasProperty(runtime, "ellipsis")) {
+      auto propValue = object.getProperty(runtime, "ellipsis");
+      auto inStr = propValue.asString(runtime).utf8(runtime);
+      std::u16string uStr;
+      fromUTF8(inStr, uStr);
+      retVal.setEllipsis(uStr);
+    }
+    if (object.hasProperty(runtime, "heightMultiplier")) {
+      auto propValue = object.getProperty(runtime, "heightMultiplier");
+      retVal.setHeight(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "maxLines")) {
+      auto propValue = object.getProperty(runtime, "maxLines");
+      if (propValue.asNumber() != 0) {
+        retVal.setMaxLines(propValue.asNumber());
+      }
+    }
+    if (object.hasProperty(runtime, "replaceTabCharacters")) {
+      auto propValue = object.getProperty(runtime, "replaceTabCharacters");
+      retVal.setReplaceTabCharacters(propValue.asBool());
+    }
+    if (object.hasProperty(runtime, "textAlign")) {
+      auto propValue = object.getProperty(runtime, "textAlign");
+      retVal.setTextAlign(static_cast<para::TextAlign>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "textDirection")) {
+      auto propValue = object.getProperty(runtime, "textDirection");
+      retVal.setTextDirection(
+          static_cast<para::TextDirection>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "textHeightBehavior")) {
+      auto propValue = object.getProperty(runtime, "textHeightBehavior");
+      retVal.setTextHeightBehavior(
+          static_cast<para::TextHeightBehavior>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "strutStyle")) {
+      auto propValue = object.getProperty(runtime, "strutStyle");
+      retVal.setStrutStyle(JsiSkStrutStyle::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "textStyle")) {
+      auto propValue = object.getProperty(runtime, "textStyle");
+      retVal.setTextStyle(JsiSkTextStyle::fromValue(runtime, propValue));
+    }
+
+    return retVal;
+  }
+
+private:
+  template <typename T>
+  static void fromUTF8(
+      const std::string &source,
+      std::basic_string<T, std::char_traits<T>, std::allocator<T>> &result) {
+    std::wstring_convert<std::codecvt_utf8_utf16<T>, T> convertor;
+    result = convertor.from_bytes(source);
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkStrutStyle.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "Paragraph.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ 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(propValue.asBool());
+    }
+    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(propValue.asBool());
+    }
+    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(propValue.asBool());
+    }
+
+    return retVal;
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTextStyle.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "Paragraph.h"
+#include "ParagraphStyle.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ Implementation of the TextStyle object in JSI for the paragraph builder
+ */
+class JsiSkTextStyle {
+public:
+  static para::TextStyle fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+
+    para::TextStyle retVal;
+
+    // Accept undefined && null
+    if (value.isUndefined() || value.isNull()) {
+      return retVal;
+    }
+
+    // Read values from the argument - expected to be a TextStyle shaped object
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime, "Expected SkTextStyle as first argument");
+    }
+
+    auto object = value.asObject(runtime);
+
+    if (object.hasProperty(runtime, "backgroundColor")) {
+      auto propValue = object.getProperty(runtime, "backgroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setBackgroundPaint(p);
+    }
+    if (object.hasProperty(runtime, "color")) {
+      auto propValue = object.getProperty(runtime, "color");
+      retVal.setColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decoration")) {
+      auto propValue = object.getProperty(runtime, "decoration");
+      retVal.setDecoration(
+          static_cast<para::TextDecoration>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "decorationColor")) {
+      auto propValue = object.getProperty(runtime, "decorationColor");
+      retVal.setDecorationColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decorationThickness")) {
+      auto propValue = object.getProperty(runtime, "decorationThickness");
+      retVal.setDecorationThicknessMultiplier(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "decorationStyle")) {
+      auto propValue = object.getProperty(runtime, "decorationStyle");
+      retVal.setDecorationStyle(
+          static_cast<para::TextDecorationStyle>(propValue.asNumber()));
+    }
+    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();
+      }
+      retVal.setFontFamilies(families);
+    }
+    if (object.hasProperty(runtime, "fontFeatures")) {
+      auto propValue = object.getProperty(runtime, "fontFeatures")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetFontFeatures();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto name = element.getProperty(runtime, "name")
+                        .asString(runtime)
+                        .utf8(runtime);
+        auto value = element.getProperty(runtime, "value").asNumber();
+        retVal.addFontFeature(SkString(name), value);
+      }
+    }
+    if (object.hasProperty(runtime, "fontSize")) {
+      auto propValue = object.getProperty(runtime, "fontSize");
+      retVal.setFontSize(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "fontStyle")) {
+      auto propValue =
+          object.getProperty(runtime, "fontStyle").asObject(runtime);
+      auto weight = static_cast<SkFontStyle::Weight>(
+          propValue.hasProperty(runtime, "weight")
+              ? propValue.getProperty(runtime, "weight").asNumber()
+              : SkFontStyle::Weight::kNormal_Weight);
+
+      auto width = static_cast<SkFontStyle::Width>(
+          propValue.hasProperty(runtime, "width")
+              ? propValue.getProperty(runtime, "width").asNumber()
+              : SkFontStyle::Width::kNormal_Width);
+
+      auto slant = static_cast<SkFontStyle::Slant>(
+          propValue.hasProperty(runtime, "slant")
+              ? propValue.getProperty(runtime, "slant").asNumber()
+              : SkFontStyle::Slant::kUpright_Slant);
+
+      retVal.setFontStyle(SkFontStyle(weight, width, slant));
+    }
+    if (object.hasProperty(runtime, "foregroundColor")) {
+      auto propValue = object.getProperty(runtime, "foregroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setForegroundColor(p);
+    }
+    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(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "letterSpacing")) {
+      auto propValue = object.getProperty(runtime, "letterSpacing");
+      retVal.setLetterSpacing(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "locale")) {
+      auto propValue = object.getProperty(runtime, "locale");
+      retVal.setLocale(SkString(propValue.asString(runtime).utf8(runtime)));
+    }
+    if (object.hasProperty(runtime, "shadows")) {
+      auto propValue = object.getProperty(runtime, "shadows")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetShadows();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto color = element.hasProperty(runtime, "color")
+                         ? JsiSkColor::fromValue(
+                               runtime, element.getProperty(runtime, "color"))
+                         : SK_ColorBLACK;
+        SkPoint offset =
+            element.hasProperty(runtime, "offset")
+                ? *JsiSkPoint::fromValue(runtime,
+                                         element.getProperty(runtime, "offset"))
+                       .get()
+                : SkPoint::Make(0, 0);
+        auto blurSigma =
+            element.hasProperty(runtime, "blurRadius")
+                ? element.getProperty(runtime, "blurRadius").asNumber()
+                : 0;
+        retVal.addShadow(para::TextShadow(color, offset, blurSigma));
+      }
+    }
+    if (object.hasProperty(runtime, "textBaseline")) {
+      auto propValue = object.getProperty(runtime, "textBaseline");
+      retVal.setTextBaseline(
+          static_cast<para::TextBaseline>(propValue.asNumber()));
+    }
+
+    return retVal;
+  }
+};
+
+} // namespace RNSkia

package/cpp/jsi/JsiHostObject.h

@@ -331,6 +331,27 @@ protected:
     return value.asHostObject<T>(runtime);
   }
 
+  /**
+   Returns argument as host object or nullptr if the value is not a valid host
+   object of requested type
+   */
+  template <typename T = HostObject>
+  static std::shared_ptr<T>
+  tryGetArgumentAsHostObject(jsi::Runtime &runtime, const jsi::Value *arguments,
+                             size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isObject()) {
+      return nullptr;
+    }
+
+    auto object = value.asObject(runtime);
+    if (!object.isHostObject(runtime)) {
+      return nullptr;
+    }
+
+    return object.asHostObject<T>(runtime);
+  }
+
   /**
    Returns argument as array or throws
    */

package/cpp/rnskia/dom/JsiDomApi.h

@@ -48,6 +48,7 @@
 #include "nodes/JsiTextPathNode.h"
 
 #include "nodes/JsiLayerNode.h"
+#include "nodes/JsiParagraphNode.h"
 
 namespace RNSkia {
 
@@ -162,6 +163,9 @@ public:
     installFunction("TextBlobNode", JsiTextBlobNode::createCtor(context));
 
     installFunction("LayerNode", JsiLayerNode::createCtor(context));
+
+    // Paragraph node
+    installFunction("ParagraphNode", JsiParagraphNode::createCtor(context));
   }
 };
 

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "ParagraphProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiParagraphNode : public JsiDomDrawingNode,
+                         public JsiDomNodeCtor<JsiParagraphNode> {
+public:
+  explicit JsiParagraphNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skParagraph") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto x = _xProp->value().getAsNumber();
+    auto y = _yProp->value().getAsNumber();
+    auto width = static_cast<SkScalar>(_widthProp->value().getAsNumber());
+
+    auto p = *_paragraphProp->getDerivedValue();
+    if (p != nullptr) {
+
+      // Let's ensure that we don't perform unnecessary layouts on the
+      // paragraph. We should only layout if we have a new paragraph or if the
+      // layout width has changed.
+      if (_lastLayoutWidth != width || _lastLayoutParagraph != p) {
+        // perform layout!
+        p->layout(width);
+        _lastLayoutWidth = width;
+        _lastLayoutParagraph = p;
+      }
+      // Paint the layout to the canvas
+      p->paint(context->getCanvas(), x, y);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _paragraphProp = container->defineProperty<ParagraphProp>("paragraph");
+
+    _xProp = container->defineProperty<NodeProp>("x");
+    _xProp->require();
+
+    _yProp = container->defineProperty<NodeProp>("y");
+    _yProp->require();
+
+    _widthProp = container->defineProperty<NodeProp>("width");
+    _widthProp->require();
+  }
+
+private:
+  ParagraphProp *_paragraphProp;
+  NodeProp *_xProp;
+  NodeProp *_yProp;
+  NodeProp *_widthProp;
+  SkScalar _lastLayoutWidth;
+  para::Paragraph *_lastLayoutParagraph = nullptr;
+};
+
+} // namespace RNSkia