@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

package/cpp/api/JsiSkTypefaceFactory.h

@@ -2,10 +2,13 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
+#include "JsiSkFontMgrFactory.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
@@ -17,22 +20,21 @@ class JsiSkTypefaceFactory : public JsiSkNativeObject<JsiSkTypefaceFactory> {
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFactory";
 
-  JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
-    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkTypeface>>
+  MakeFreeTypeFaceFromData(sk_sp<SkData> data) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     auto typeface = fontMgr->makeFromData(std::move(data));
     if (typeface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    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 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeFreeTypeFaceFromData",
-                      &JsiSkTypefaceFactory::MakeFreeTypeFaceFromData);
+    installMethod(runtime, prototype, "MakeFreeTypeFaceFromData",
+                  &JsiSkTypefaceFactory::MakeFreeTypeFaceFromData);
   }
 
   explicit JsiSkTypefaceFactory(std::shared_ptr<RNSkPlatformContext> context)

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -1,10 +1,13 @@
 #pragma once
 
 #include <memory>
+#include <optional>
+#include <string>
 #include <utility>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFontStyle.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
@@ -30,18 +33,16 @@ class JsiSkTypefaceFontProvider
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFontProvider";
 
-  JSI_HOST_FUNCTION(registerFont) {
-    sk_sp<SkTypeface> typeface =
-        JsiSkTypeface::fromValue(runtime, arguments[0]);
-    SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
+  void registerFont(sk_sp<SkTypeface> typeface, std::string familyNameStr) {
+    SkString familyName(familyNameStr.c_str());
     getObject()->registerTypeface(typeface, familyName);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(matchFamilyStyle) {
-    auto name = count > 0 ? arguments[0].asString(runtime).utf8(runtime) : "";
-    auto fontStyle =
-        count > 1 ? JsiSkFontStyle::fromValue(runtime, arguments[1]) : nullptr;
+  std::shared_ptr<JsiSkTypeface>
+  matchFamilyStyle(std::optional<std::string> nameParam,
+                   std::optional<std::shared_ptr<SkFontStyle>> fontStyleParam) {
+    auto name = nameParam.value_or("");
+    auto fontStyle = fontStyleParam.value_or(nullptr);
     if (name == "" || fontStyle == nullptr) {
       throw std::runtime_error("matchFamilyStyle requires a name and a style");
     }
@@ -53,17 +54,15 @@ public:
     if (!typeface) {
       throw std::runtime_error("Could not find font style for " + name);
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
-                                      getContext(), std::move(typeface)));
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
-  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+  int countFamilies() { return getObject()->countFamilies(); }
 
-  JSI_HOST_FUNCTION(getFamilyName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getFamilyName(int i) {
     SkString name;
     getObject()->getFamilyName(i, &name);
-    return jsi::String::createFromUtf8(runtime, name.c_str());
+    return std::string(name.c_str());
   }
 
   JsiSkTypefaceFontProvider(std::shared_ptr<RNSkPlatformContext> context,
@@ -92,14 +91,14 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "registerFont",
-                      &JsiSkTypefaceFontProvider::registerFont);
-    installHostMethod(runtime, prototype, "matchFamilyStyle",
-                      &JsiSkTypefaceFontProvider::matchFamilyStyle);
-    installHostMethod(runtime, prototype, "countFamilies",
-                      &JsiSkTypefaceFontProvider::countFamilies);
-    installHostMethod(runtime, prototype, "getFamilyName",
-                      &JsiSkTypefaceFontProvider::getFamilyName);
+    installMethod(runtime, prototype, "registerFont",
+                  &JsiSkTypefaceFontProvider::registerFont);
+    installMethod(runtime, prototype, "matchFamilyStyle",
+                  &JsiSkTypefaceFontProvider::matchFamilyStyle);
+    installMethod(runtime, prototype, "countFamilies",
+                  &JsiSkTypefaceFontProvider::countFamilies);
+    installMethod(runtime, prototype, "getFamilyName",
+                  &JsiSkTypefaceFontProvider::getFamilyName);
   }
 };
 

package/cpp/api/JsiSkTypefaceFontProviderFactory.h

@@ -19,17 +19,16 @@ class JsiSkTypefaceFontProviderFactory
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFontProviderFactory";
 
-  JSI_HOST_FUNCTION(Make) {
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
-                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
+  std::shared_ptr<JsiSkTypefaceFontProvider> Make() {
+    return std::make_shared<JsiSkTypefaceFontProvider>(
+        getContext(), sk_make_sp<para::TypefaceFontProvider>());
   }
 
   size_t getMemoryPressure() override { return 2048; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Make",
-                      &JsiSkTypefaceFontProviderFactory::Make);
+    installMethod(runtime, prototype, "Make",
+                  &JsiSkTypefaceFontProviderFactory::Make);
   }
 
   explicit JsiSkTypefaceFontProviderFactory(

package/cpp/api/JsiSkVertices.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "JsiSkNativeObjects.h"
+#include "JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -28,15 +29,12 @@ public:
       : JsiSkWrappingSkPtrNativeObject<JsiSkVertices, SkVertices>(
             std::move(context), std::move(vertices)) {}
 
-  JSI_HOST_FUNCTION(bounds) {
+  std::shared_ptr<JsiSkRect> bounds() {
     const auto &result = getObject()->bounds();
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkRect>(getContext(), result));
+    return std::make_shared<JsiSkRect>(getContext(), result);
   }
 
-  JSI_HOST_FUNCTION(uniqueID) {
-    return static_cast<double>(getObject()->uniqueID());
-  }
+  double uniqueID() { return static_cast<double>(getObject()->uniqueID()); }
 
   size_t getMemoryPressure() override {
     auto vertices = getObject();
@@ -54,8 +52,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
-    installHostMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
+    installMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
+    installMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
   }
 
   /**

package/cpp/api/JsiSkiaContext.h

@@ -3,8 +3,10 @@
 #include <memory>
 #include <numeric>
 #include <utility>
+#include <variant>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
@@ -12,6 +14,7 @@
 #include "JsiSkPaint.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
+#include "JsiSkSurface.h"
 #include "JsiSkTypeface.h"
 
 #include "rnskia/RNWindowContext.h"
@@ -33,25 +36,21 @@ class JsiSkiaContext
 public:
   static constexpr const char *CLASS_NAME = "SkiaContext";
 
-  JSI_HOST_FUNCTION(getSurface) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkSurface>> getSurface() {
     auto surface = getObject()->getSurface();
     if (surface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
-                                      getContext(), std::move(surface)));
+    return std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
   }
 
-  JSI_HOST_FUNCTION(present) {
-    getObject()->present();
-    return jsi::Value::undefined();
-  }
+  void present() { getObject()->present(); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "getSurface",
-                      &JsiSkiaContext::getSurface);
-    installHostMethod(runtime, prototype, "present", &JsiSkiaContext::present);
+    installMethod(runtime, prototype, "getSurface",
+                  &JsiSkiaContext::getSurface);
+    installMethod(runtime, prototype, "present", &JsiSkiaContext::present);
   }
 
   JsiSkiaContext(std::shared_ptr<RNSkPlatformContext> context,

package/cpp/api/JsiVideo.h

@@ -1,29 +1,17 @@
 #pragma once
 
 #include <memory>
-#include <numeric>
 #include <utility>
-#include <vector>
+#include <variant>
 
 #include "JsiSkNativeObjects.h"
-#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
-#include "JsiSkPaint.h"
-#include "JsiSkPoint.h"
-#include "JsiSkRect.h"
-#include "JsiSkTypeface.h"
+#include "JsiSkConverters.h"
+#include "JsiSkImage.h"
 
 #include "rnskia/RNSkVideo.h"
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkFont.h"
-#include "include/core/SkFontMetrics.h"
-
-#pragma clang diagnostic pop
-
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
@@ -33,83 +21,55 @@ class JsiVideo
 public:
   static constexpr const char *CLASS_NAME = "Video";
 
-  JSI_HOST_FUNCTION(nextImage) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>> nextImage() {
     double timestamp = 0;
-    auto video = getObject();
-    auto image = video->nextImage(&timestamp);
+    auto image = getObject()->nextImage(&timestamp);
     if (!image) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(duration) { return getObject()->duration(); }
+  double duration() { return getObject()->duration(); }
 
-  JSI_HOST_FUNCTION(framerate) { return getObject()->framerate(); }
+  double framerate() { return getObject()->framerate(); }
 
-  JSI_HOST_FUNCTION(currentTime) { return getObject()->currentTime(); }
+  double currentTime() { return getObject()->currentTime(); }
 
-  JSI_HOST_FUNCTION(isPlaying) { return getObject()->isPlaying(); }
+  bool isPlaying() { return getObject()->isPlaying(); }
 
-  JSI_HOST_FUNCTION(seek) {
-    double timestamp = arguments[0].asNumber();
-    getObject()->seek(timestamp);
-    return jsi::Value::undefined();
-  }
+  void seek(double timestamp) { getObject()->seek(timestamp); }
 
-  JSI_HOST_FUNCTION(rotation) {
-    auto context = getContext();
-    auto rot = getObject()->getRotationInDegrees();
-    return jsi::Value(static_cast<double>(rot));
+  double rotation() {
+    return static_cast<double>(getObject()->getRotationInDegrees());
   }
 
-  JSI_HOST_FUNCTION(size) {
-    auto context = getContext();
-    auto size = getObject()->getSize();
-    auto result = jsi::Object(runtime);
-    result.setProperty(runtime, "width", static_cast<double>(size.width()));
-    result.setProperty(runtime, "height", static_cast<double>(size.height()));
-    return result;
-  }
+  SkISize size() { return getObject()->getSize(); }
 
-  JSI_HOST_FUNCTION(play) {
-    getObject()->play();
-    return jsi::Value::undefined();
-  }
+  void play() { getObject()->play(); }
 
-  JSI_HOST_FUNCTION(pause) {
-    getObject()->pause();
-    return jsi::Value::undefined();
-  }
+  void pause() { getObject()->pause(); }
 
-  JSI_HOST_FUNCTION(setVolume) {
-    auto volume = arguments[0].asNumber();
+  void setVolume(double volume) {
     getObject()->setVolume(static_cast<float>(volume));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setLooping) {
-    auto looping = arguments[0].asBool();
-    getObject()->setLooping(looping);
-    return jsi::Value::undefined();
-  }
+  void setLooping(bool looping) { getObject()->setLooping(looping); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "nextImage", &JsiVideo::nextImage);
-    installHostMethod(runtime, prototype, "duration", &JsiVideo::duration);
-    installHostMethod(runtime, prototype, "framerate", &JsiVideo::framerate);
-    installHostMethod(runtime, prototype, "currentTime",
-                      &JsiVideo::currentTime);
-    installHostMethod(runtime, prototype, "isPlaying", &JsiVideo::isPlaying);
-    installHostMethod(runtime, prototype, "seek", &JsiVideo::seek);
-    installHostMethod(runtime, prototype, "rotation", &JsiVideo::rotation);
-    installHostMethod(runtime, prototype, "size", &JsiVideo::size);
-    installHostMethod(runtime, prototype, "play", &JsiVideo::play);
-    installHostMethod(runtime, prototype, "pause", &JsiVideo::pause);
-    installHostMethod(runtime, prototype, "setVolume", &JsiVideo::setVolume);
-    installHostMethod(runtime, prototype, "setLooping", &JsiVideo::setLooping);
+    installMethod(runtime, prototype, "nextImage", &JsiVideo::nextImage);
+    installMethod(runtime, prototype, "duration", &JsiVideo::duration);
+    installMethod(runtime, prototype, "framerate", &JsiVideo::framerate);
+    installMethod(runtime, prototype, "currentTime", &JsiVideo::currentTime);
+    installMethod(runtime, prototype, "isPlaying", &JsiVideo::isPlaying);
+    installMethod(runtime, prototype, "seek", &JsiVideo::seek);
+    installMethod(runtime, prototype, "rotation", &JsiVideo::rotation);
+    installMethod(runtime, prototype, "size", &JsiVideo::size);
+    installMethod(runtime, prototype, "play", &JsiVideo::play);
+    installMethod(runtime, prototype, "pause", &JsiVideo::pause);
+    installMethod(runtime, prototype, "setVolume", &JsiVideo::setVolume);
+    installMethod(runtime, prototype, "setLooping", &JsiVideo::setLooping);
   }
 
   JsiVideo(std::shared_ptr<RNSkPlatformContext> context,

package/cpp/dawn/include/dawn/dawn_proc.h

@@ -0,0 +1,53 @@
+// Copyright 2019 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_DAWN_DAWN_PROC_H_
+#define INCLUDE_DAWN_DAWN_PROC_H_
+
+#include <webgpu/webgpu.h>
+
+#include "dawn/dawn_proc_table.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Sets the static proctable used by libdawn_proc to implement the Dawn entrypoints. Passing NULL
+// for `procs` sets up the null proctable that contains only null function pointers. It is the
+// default value of the proctable. Setting the proctable back to null is good practice when you
+// are done using libdawn_proc since further usage will cause a segfault instead of calling an
+// unexpected function.
+WGPU_EXPORT void dawnProcSetProcs(const DawnProcTable* procs);
+
+// Returns the static array of uint8_t of size 20 representing the Dawn version.
+WGPU_EXPORT const uint8_t* dawnProcGetVersion();
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // INCLUDE_DAWN_DAWN_PROC_H_