@shopify/react-native-skia 0.1.222 → 0.1.224

package/cpp/api/JsiSkApi.h

@@ -24,6 +24,7 @@
 #include "JsiSkMaskFilterFactory.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkPaint.h"
+#include "JsiSkParagraphBuilder.h"
 #include "JsiSkPath.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkPathEffectFactory.h"
@@ -43,9 +44,9 @@
 #include "JsiSkShaderFactory.h"
 #include "JsiSkSurfaceFactory.h"
 #include "JsiSkTextBlobFactory.h"
-#include "JsiSkTypeFaceFontProviderFactory.h"
 #include "JsiSkTypeface.h"
 #include "JsiSkTypefaceFactory.h"
+#include "JsiSkTypefaceFontProviderFactory.h"
 #include "JsiSkVertices.h"
 
 namespace RNSkia {
@@ -112,6 +113,10 @@ public:
     installReadonlyProperty(
         "TypefaceFontProvider",
         std::make_shared<JsiSkTypefaceFontProviderFactory>(context));
+
+    installReadonlyProperty(
+        "ParagraphBuilder",
+        std::make_shared<JsiSkParagraphBuilderFactory>(context));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkFontMgrFactory.h

@@ -22,13 +22,18 @@ namespace jsi = facebook::jsi;
 
 class JsiSkFontMgrFactory : public JsiSkHostObject {
 public:
-  JSI_HOST_FUNCTION(System) {
-    auto context = getContext();
+  static sk_sp<SkFontMgr>
+  getFontMgr(std::shared_ptr<RNSkPlatformContext> context) {
     static SkOnce once;
     static sk_sp<SkFontMgr> fontMgr;
-    once([&context, &runtime] { fontMgr = context->createFontMgr(); });
+    once([&context] { fontMgr = context->createFontMgr(); });
+    return fontMgr;
+  }
+
+  JSI_HOST_FUNCTION(System) {
+    auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkFontMgr>(std::move(context), fontMgr));
+        runtime, std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))

package/cpp/api/JsiSkParagraph.h

@@ -0,0 +1,135 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkCanvas.h>
+#include <JsiSkHostObjects.h>
+#include <JsiSkPath.h>
+#include <JsiSkRect.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "Paragraph.h"
+#include "ParagraphBuilder.h"
+#include "ParagraphStyle.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ Implementation of the Paragraph object in JSI
+ */
+class JsiSkParagraph : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(layout) {
+    auto width = getArgumentAsNumber(runtime, arguments, count, 0);
+    _paragraph->layout(width);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(paint) {
+    auto jsiCanvas =
+        getArgumentAsHostObject<JsiSkCanvas>(runtime, arguments, count, 0);
+    auto x = getArgumentAsNumber(runtime, arguments, count, 1);
+    auto y = getArgumentAsNumber(runtime, arguments, count, 2);
+    _paragraph->paint(jsiCanvas->getCanvas(), x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(getHeight) {
+    return static_cast<double>(_paragraph->getHeight());
+  }
+
+  JSI_HOST_FUNCTION(getMaxWidth) {
+    return static_cast<double>(_paragraph->getMaxWidth());
+  }
+
+  JSI_HOST_FUNCTION(getGlyphPositionAtCoordinate) {
+    auto dx = getArgumentAsNumber(runtime, arguments, count, 0);
+    auto dy = getArgumentAsNumber(runtime, arguments, count, 1);
+    auto result = _paragraph->getGlyphPositionAtCoordinate(dx, dy);
+    return result.position;
+  }
+
+  JSI_HOST_FUNCTION(getRectsForRange) {
+    auto start = getArgumentAsNumber(runtime, arguments, count, 0);
+    auto end = getArgumentAsNumber(runtime, arguments, count, 1);
+    auto result =
+        _paragraph->getRectsForRange(start, end, para::RectHeightStyle::kTight,
+                                     para::RectWidthStyle::kTight);
+    auto returnValue = jsi::Array(runtime, result.size());
+    for (size_t i = 0; i < result.size(); ++i) {
+      returnValue.setValueAtIndex(
+          runtime, i,
+          JsiSkRect::toValue(runtime, getContext(), result[i].rect));
+    }
+    return returnValue;
+  }
+
+  JSI_HOST_FUNCTION(getLineMetrics) {
+    std::vector<para::LineMetrics> metrics;
+    _paragraph->getLineMetrics(metrics);
+    auto returnValue = jsi::Array(runtime, metrics.size());
+    auto height = 0;
+    for (size_t i = 0; i < metrics.size(); ++i) {
+      returnValue.setValueAtIndex(
+          runtime, i,
+          JsiSkRect::toValue(runtime, getContext(),
+                             SkRect::MakeXYWH(metrics[i].fLeft, height,
+                                              metrics[i].fWidth,
+                                              metrics[i].fHeight)));
+      height += metrics[i].fHeight;
+    }
+    return returnValue;
+  }
+
+  JSI_HOST_FUNCTION(getRectsForPlaceholders) {
+    std::vector<para::TextBox> placeholderInfos =
+        _paragraph->getRectsForPlaceholders();
+    auto returnValue = jsi::Array(runtime, placeholderInfos.size());
+    for (size_t i = 0; i < placeholderInfos.size(); ++i) {
+      auto obj = jsi::Object(runtime);
+      obj.setProperty(
+          runtime, "rect",
+          JsiSkRect::toValue(runtime, getContext(), placeholderInfos[i].rect));
+      obj.setProperty(runtime, "direction",
+                      static_cast<double>(placeholderInfos[i].direction));
+      returnValue.setValueAtIndex(runtime, i, obj);
+    }
+    return returnValue;
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraph, layout),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, paint),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, getMaxWidth),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, getHeight),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, getRectsForPlaceholders),
+                       JSI_EXPORT_FUNC(JsiSkParagraph,
+                                       getGlyphPositionAtCoordinate),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, getRectsForRange),
+                       JSI_EXPORT_FUNC(JsiSkParagraph, getLineMetrics))
+
+  explicit JsiSkParagraph(std::shared_ptr<RNSkPlatformContext> context,
+                          para::ParagraphBuilder *paragraphBuilder)
+      : JsiSkHostObject(std::move(context)) {
+    _paragraph = paragraphBuilder->Build();
+  }
+
+  para::Paragraph *getParagraph() { return _paragraph.get(); }
+
+private:
+  std::unique_ptr<para::Paragraph> _paragraph;
+};
+
+} // namespace RNSkia

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