@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/api/JsiSkFont.h

@@ -2,13 +2,17 @@
 
 #include <memory>
 #include <numeric>
+#include <optional>
+#include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkPaint.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
@@ -30,39 +34,26 @@ class JsiSkFont : public JsiSkWrappingSharedPtrNativeObject<JsiSkFont, SkFont> {
 public:
   static constexpr const char *CLASS_NAME = "Font";
 
-  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());
-    }
-    auto widths = SkSpan(static_cast<SkScalar *>(widthPtrs.data()), glyphsSize);
-    auto g = SkSpan(glyphs.data(), glyphs.size());
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(g, widths, {}, paint.get());
-    } else {
-      getObject()->getWidthsBounds(g, widths, {}, 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])));
+  std::vector<double>
+  getGlyphWidths(std::vector<int> glyphs,
+                 std::optional<std::shared_ptr<SkPaint>> paint) {
+    std::vector<SkGlyphID> glyphIds;
+    glyphIds.reserve(glyphs.size());
+    for (auto glyph : glyphs) {
+      glyphIds.push_back(static_cast<SkGlyphID>(glyph));
     }
-    return jsiWidths;
+    std::vector<SkScalar> widths;
+    widths.resize(glyphIds.size());
+    auto g = SkSpan(glyphIds.data(), glyphIds.size());
+    auto w = SkSpan(widths.data(), widths.size());
+    getObject()->getWidthsBounds(
+        g, w, {}, paint.has_value() ? paint.value().get() : nullptr);
+    return std::vector<double>(widths.begin(), widths.end());
   }
 
   // TODO: deprecate
-  JSI_HOST_FUNCTION(getTextWidth) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
+  int getTextWidth(std::string str,
+                   std::optional<std::shared_ptr<SkPaint>> paint) {
     auto numGlyphIDs = getObject()->countText(str.c_str(), str.length(),
                                               SkTextEncoding::kUTF8);
     std::vector<SkGlyphID> glyphs;
@@ -70,33 +61,25 @@ public:
     auto g = SkSpan(glyphs.data(), glyphs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                               g);
-    std::vector<SkScalar> widthPtrs;
-    widthPtrs.resize(numGlyphIDs);
-    auto widths = SkSpan(widthPtrs.data(), widthPtrs.size());
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(g, widths, {}, paint.get());
-    } else {
-      getObject()->getWidthsBounds(g, widths, {}, nullptr);
-    }
-    return jsi::Value(std::accumulate(widthPtrs.begin(), widthPtrs.end(), 0));
+    std::vector<SkScalar> widths;
+    widths.resize(numGlyphIDs);
+    auto w = SkSpan(widths.data(), widths.size());
+    getObject()->getWidthsBounds(
+        g, w, {}, paint.has_value() ? paint.value().get() : nullptr);
+    return std::accumulate(widths.begin(), widths.end(), 0);
   }
 
-  JSI_HOST_FUNCTION(measureText) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkRect>
+  measureText(std::string str, std::optional<std::shared_ptr<SkPaint>> paint) {
     SkRect bounds;
-    if (count > 1) {
-      auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                               &bounds, paint.get());
-    } else {
-      getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                               &bounds);
-    }
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(bounds)));
+    getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
+                             &bounds,
+                             paint.has_value() ? paint.value().get() : nullptr);
+    return std::make_shared<JsiSkRect>(getContext(), bounds);
   }
 
+  // Stays raw: the result object has a conditionally present `bounds`
+  // property, which a typed return value cannot express.
   JSI_HOST_FUNCTION(getMetrics) {
     SkFontMetrics fm;
     getObject()->getMetrics(&fm);
@@ -113,178 +96,114 @@ public:
     return metrics;
   }
 
-  JSI_HOST_FUNCTION(getGlyphIDs) {
-    auto str = arguments[0].asString(runtime).utf8(runtime);
-    int numGlyphIDs =
-        count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
-            ? static_cast<int>(arguments[1].asNumber())
-            : getObject()->countText(str.c_str(), str.length(),
-                                     SkTextEncoding::kUTF8);
+  std::vector<int> getGlyphIDs(std::string str, JsiOptional<int> numGlyphs) {
+    int numGlyphIDs = numGlyphs.has_value()
+                          ? *numGlyphs
+                          : getObject()->countText(str.c_str(), str.length(),
+                                                   SkTextEncoding::kUTF8);
     std::vector<SkGlyphID> glyphIDs;
     glyphIDs.resize(numGlyphIDs);
     auto g = SkSpan(static_cast<SkGlyphID *>(glyphIDs.data()), glyphIDs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                               g);
-    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;
+    return std::vector<int>(glyphIDs.begin(), glyphIDs.end());
   }
 
-  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());
+  std::vector<int> getGlyphIntercepts(std::vector<int> glyphs,
+                                      std::vector<SkPoint> positions,
+                                      double top, double bottom) {
+    std::vector<SkGlyphID> glyphIds;
+    glyphIds.reserve(glyphs.size());
+    for (auto glyph : glyphs) {
+      glyphIds.push_back(static_cast<SkGlyphID>(glyph));
     }
-
-    if (glyphs.size() > positions.size()) {
-      throw jsi::JSError(runtime, "Not enough x,y position pairs for glyphs");
-      return jsi::Value::null();
+    if (glyphIds.size() > positions.size()) {
+      throw std::runtime_error("Not enough x,y position pairs for glyphs");
     }
-    auto g = SkSpan(glyphs.data(), glyphs.size());
+    auto g = SkSpan(glyphIds.data(), glyphIds.size());
     auto p = SkSpan(positions.data(), positions.size());
     auto sects = getObject()->getIntercepts(g, p, 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;
+    return std::vector<int>(sects.begin(), sects.end());
   }
 
-  JSI_HOST_FUNCTION(getScaleX) {
-    return jsi::Value(SkScalarToDouble(getObject()->getScaleX()));
-  }
+  double getScaleX() { return SkScalarToDouble(getObject()->getScaleX()); }
 
-  JSI_HOST_FUNCTION(getSize) {
-    return jsi::Value(SkScalarToDouble(getObject()->getSize()));
-  }
+  double getSize() { return SkScalarToDouble(getObject()->getSize()); }
 
-  JSI_HOST_FUNCTION(getSkewX) {
-    return jsi::Value(SkScalarToDouble(getObject()->getSkewX()));
-  }
+  double getSkewX() { return SkScalarToDouble(getObject()->getSkewX()); }
 
-  JSI_HOST_FUNCTION(isEmbolden) {
-    return jsi::Value(getObject()->isEmbolden());
-  }
+  bool isEmbolden() { return getObject()->isEmbolden(); }
 
-  JSI_HOST_FUNCTION(getTypeface) {
-    return JsiSkTypeface::toValue(
-        runtime, getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
+  std::shared_ptr<JsiSkTypeface> getTypeface() {
+    return std::make_shared<JsiSkTypeface>(
+        getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
   }
 
-  JSI_HOST_FUNCTION(setEdging) {
-    auto edging = arguments[0].asNumber();
+  void setEdging(double edging) {
     getObject()->setEdging(static_cast<SkFont::Edging>(edging));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(embeddedBitmaps) {
-    auto embeddedBitmaps = arguments[0].getBool();
+  void setEmbeddedBitmaps(bool embeddedBitmaps) {
     getObject()->setEmbeddedBitmaps(embeddedBitmaps);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setHinting) {
-    auto hinting = arguments[0].asNumber();
+  void setHinting(double hinting) {
     getObject()->setHinting(static_cast<SkFontHinting>(hinting));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setLinearMetrics) {
-    auto linearMetrics = arguments[0].getBool();
+  void setLinearMetrics(bool linearMetrics) {
     getObject()->setLinearMetrics(linearMetrics);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setScaleX) {
-    auto scaleX = arguments[0].asNumber();
-    getObject()->setScaleX(scaleX);
-    return jsi::Value::undefined();
-  }
+  void setScaleX(double scaleX) { getObject()->setScaleX(scaleX); }
 
-  JSI_HOST_FUNCTION(setSkewX) {
-    auto skewX = arguments[0].asNumber();
-    getObject()->setSkewX(skewX);
-    return jsi::Value::undefined();
-  }
+  void setSkewX(double skewX) { getObject()->setSkewX(skewX); }
 
-  JSI_HOST_FUNCTION(setSize) {
-    auto size = arguments[0].asNumber();
-    getObject()->setSize(size);
-    return jsi::Value::undefined();
-  }
+  void setSize(double size) { getObject()->setSize(size); }
 
-  JSI_HOST_FUNCTION(setEmbolden) {
-    auto embolden = arguments[0].asNumber();
-    getObject()->setEmbolden(embolden);
-    return jsi::Value::undefined();
+  // The JS API declares booleans here, but the previous implementation read
+  // the arguments with asNumber() — keep accepting numbers.
+  void setEmbolden(double embolden) {
+    getObject()->setEmbolden(static_cast<bool>(embolden));
   }
 
-  JSI_HOST_FUNCTION(setSubpixel) {
-    auto subpixel = arguments[0].asNumber();
-    getObject()->setSubpixel(subpixel);
-    return jsi::Value::undefined();
+  void setSubpixel(double subpixel) {
+    getObject()->setSubpixel(static_cast<bool>(subpixel));
   }
 
-  JSI_HOST_FUNCTION(setTypeface) {
-    auto typeface = arguments[0].isNull()
-                        ? nullptr
-                        : JsiSkTypeface::fromValue(runtime, arguments[0]);
-    getObject()->setTypeface(typeface);
-    return jsi::Value::undefined();
+  void setTypeface(std::variant<std::nullptr_t, sk_sp<SkTypeface>> typeface) {
+    getObject()->setTypeface(
+        std::holds_alternative<std::nullptr_t>(typeface)
+            ? nullptr
+            : std::get<sk_sp<SkTypeface>>(std::move(typeface)));
   }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "getSize", &JsiSkFont::getSize);
+    installMethod(runtime, prototype, "getSize", &JsiSkFont::getSize);
     installHostMethod(runtime, prototype, "getMetrics", &JsiSkFont::getMetrics);
-    installHostMethod(runtime, prototype, "getGlyphIDs",
-                      &JsiSkFont::getGlyphIDs);
-    installHostMethod(runtime, prototype, "getGlyphIntercepts",
-                      &JsiSkFont::getGlyphIntercepts);
-    installHostMethod(runtime, prototype, "getScaleX", &JsiSkFont::getScaleX);
-    installHostMethod(runtime, prototype, "getSkewX", &JsiSkFont::getSkewX);
-    installHostMethod(runtime, prototype, "getTypeface",
-                      &JsiSkFont::getTypeface);
-    installHostMethod(runtime, prototype, "setEdging", &JsiSkFont::setEdging);
-    installHostMethod(runtime, prototype, "embeddedBitmaps",
-                      &JsiSkFont::embeddedBitmaps);
-    installHostMethod(runtime, prototype, "setHinting", &JsiSkFont::setHinting);
-    installHostMethod(runtime, prototype, "setLinearMetrics",
-                      &JsiSkFont::setLinearMetrics);
-    installHostMethod(runtime, prototype, "setScaleX", &JsiSkFont::setScaleX);
-    installHostMethod(runtime, prototype, "setSkewX", &JsiSkFont::setSkewX);
-    installHostMethod(runtime, prototype, "setSize", &JsiSkFont::setSize);
-    installHostMethod(runtime, prototype, "setEmbolden",
-                      &JsiSkFont::setEmbolden);
-    installHostMethod(runtime, prototype, "setSubpixel",
-                      &JsiSkFont::setSubpixel);
-    installHostMethod(runtime, prototype, "setTypeface",
-                      &JsiSkFont::setTypeface);
-    installHostMethod(runtime, prototype, "getGlyphWidths",
-                      &JsiSkFont::getGlyphWidths);
-    installHostMethod(runtime, prototype, "getTextWidth",
-                      &JsiSkFont::getTextWidth);
-    installHostMethod(runtime, prototype, "measureText",
-                      &JsiSkFont::measureText);
+    installMethod(runtime, prototype, "getGlyphIDs", &JsiSkFont::getGlyphIDs);
+    installMethod(runtime, prototype, "getGlyphIntercepts",
+                  &JsiSkFont::getGlyphIntercepts);
+    installMethod(runtime, prototype, "getScaleX", &JsiSkFont::getScaleX);
+    installMethod(runtime, prototype, "getSkewX", &JsiSkFont::getSkewX);
+    installMethod(runtime, prototype, "getTypeface", &JsiSkFont::getTypeface);
+    installMethod(runtime, prototype, "setEdging", &JsiSkFont::setEdging);
+    installMethod(runtime, prototype, "embeddedBitmaps",
+                  &JsiSkFont::setEmbeddedBitmaps);
+    installMethod(runtime, prototype, "setHinting", &JsiSkFont::setHinting);
+    installMethod(runtime, prototype, "setLinearMetrics",
+                  &JsiSkFont::setLinearMetrics);
+    installMethod(runtime, prototype, "setScaleX", &JsiSkFont::setScaleX);
+    installMethod(runtime, prototype, "setSkewX", &JsiSkFont::setSkewX);
+    installMethod(runtime, prototype, "setSize", &JsiSkFont::setSize);
+    installMethod(runtime, prototype, "setEmbolden", &JsiSkFont::setEmbolden);
+    installMethod(runtime, prototype, "setSubpixel", &JsiSkFont::setSubpixel);
+    installMethod(runtime, prototype, "setTypeface", &JsiSkFont::setTypeface);
+    installMethod(runtime, prototype, "getGlyphWidths",
+                  &JsiSkFont::getGlyphWidths);
+    installMethod(runtime, prototype, "getTextWidth", &JsiSkFont::getTextWidth);
+    installMethod(runtime, prototype, "measureText", &JsiSkFont::measureText);
   }
 
   JsiSkFont(std::shared_ptr<RNSkPlatformContext> context, const SkFont &font)

package/cpp/api/JsiSkFontMgr.h

@@ -2,11 +2,14 @@
 
 #include <memory>
 #include <numeric>
+#include <string>
 #include <utility>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFontStyle.h"
 #include "JsiSkNativeObjects.h"
+#include "JsiSkTypeface.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
@@ -32,41 +35,36 @@ public:
                                                                 fontMgr),
         _systemFontFamilies(context->getSystemFontFamilies()) {}
 
-  JSI_HOST_FUNCTION(countFamilies) {
+  int countFamilies() {
     return static_cast<int>(getObject()->countFamilies() +
                             _systemFontFamilies.size());
   }
 
-  JSI_HOST_FUNCTION(getFamilyName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getFamilyName(int i) {
     auto baseFamilyCount = getObject()->countFamilies();
     if (i < baseFamilyCount) {
       SkString name;
       getObject()->getFamilyName(i, &name);
-      return jsi::String::createFromUtf8(runtime, name.c_str());
+      return std::string(name.c_str());
     }
     auto systemIndex = i - baseFamilyCount;
     if (systemIndex < static_cast<int>(_systemFontFamilies.size())) {
-      return jsi::String::createFromUtf8(runtime,
-                                         _systemFontFamilies[systemIndex]);
+      return _systemFontFamilies[systemIndex];
     }
-    throw jsi::JSError(
-        runtime,
+    throw std::runtime_error(
         "Font family index out of bounds: " + std::to_string(i) +
-            " (total families: " +
-            std::to_string(baseFamilyCount + _systemFontFamilies.size()) + ")");
+        " (total families: " +
+        std::to_string(baseFamilyCount + _systemFontFamilies.size()) + ")");
   }
 
-  JSI_HOST_FUNCTION(matchFamilyStyle) {
-    auto name = arguments[0].asString(runtime).utf8(runtime);
+  std::shared_ptr<JsiSkTypeface>
+  matchFamilyStyle(std::string name, std::shared_ptr<SkFontStyle> fontStyle) {
     // Resolve font family aliases (e.g., "System" -> ".AppleSystemUIFont" on
     // iOS)
     auto resolvedName = getContext()->resolveFontFamily(name);
-    auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
     auto typeface =
         getObject()->matchFamilyStyle(resolvedName.c_str(), *fontStyle);
-    return makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
-                                      getContext(), std::move(typeface)));
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
   size_t getMemoryPressure() override { return 2048; }
@@ -78,12 +76,12 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "countFamilies",
-                      &JsiSkFontMgr::countFamilies);
-    installHostMethod(runtime, prototype, "getFamilyName",
-                      &JsiSkFontMgr::getFamilyName);
-    installHostMethod(runtime, prototype, "matchFamilyStyle",
-                      &JsiSkFontMgr::matchFamilyStyle);
+    installMethod(runtime, prototype, "countFamilies",
+                  &JsiSkFontMgr::countFamilies);
+    installMethod(runtime, prototype, "getFamilyName",
+                  &JsiSkFontMgr::getFamilyName);
+    installMethod(runtime, prototype, "matchFamilyStyle",
+                  &JsiSkFontMgr::matchFamilyStyle);
   }
 
 private:

package/cpp/api/JsiSkFontMgrFactory.h

@@ -6,6 +6,7 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkFontMgr.h"
 #include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
@@ -32,17 +33,15 @@ public:
     return fontMgr;
   }
 
-  JSI_HOST_FUNCTION(System) {
+  std::shared_ptr<JsiSkFontMgr> System() {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
+    return std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "System",
-                      &JsiSkFontMgrFactory::System);
+    installMethod(runtime, prototype, "System", &JsiSkFontMgrFactory::System);
   }
 
   explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)