@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Base.h

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/bridging/Convert.h>
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+namespace facebook::react {
+
+class CallInvoker;
+
+template <typename T, typename = void>
+struct Bridging;
+
+template <>
+struct Bridging<void> {
+  // Highly generic code may result in "casting" to void.
+  static void fromJs(jsi::Runtime&, const jsi::Value&) {}
+};
+
+namespace bridging {
+namespace detail {
+
+template <typename F>
+struct function_wrapper;
+
+template <typename ClassT, typename ReturnT, typename... ArgsT>
+struct function_wrapper<ReturnT (ClassT::*)(ArgsT...)> {
+  using type = std::function<ReturnT(ArgsT...)>;
+};
+
+template <typename ClassT, typename ReturnT, typename... ArgsT>
+struct function_wrapper<ReturnT (ClassT::*)(ArgsT...) const> {
+  using type = std::function<ReturnT(ArgsT...)>;
+};
+
+template <typename T, typename = void>
+struct bridging_wrapper {
+  using type = remove_cvref_t<T>;
+};
+
+// Convert lambda types to move-only function types since we can't specialize
+// Bridging templates for arbitrary lambdas.
+template <typename T>
+struct bridging_wrapper<
+    T,
+    std::void_t<decltype(&remove_cvref_t<T>::operator())>>
+    : function_wrapper<decltype(&remove_cvref_t<T>::operator())> {};
+
+} // namespace detail
+
+template <typename T>
+using bridging_t = typename detail::bridging_wrapper<T>::type;
+
+template <typename ReturnT, typename JSArgT>
+  requires is_jsi_v<JSArgT>
+auto fromJs(
+    jsi::Runtime& rt,
+    JSArgT&& value,
+    const std::shared_ptr<CallInvoker>& /*unused*/)
+    -> decltype(static_cast<ReturnT>(
+        std::move(convert(rt, std::forward<JSArgT>(value)))))
+
+{
+  return static_cast<ReturnT>(
+      std::move(convert(rt, std::forward<JSArgT>(value))));
+}
+
+template <typename ReturnT, typename JSArgT>
+auto fromJs(
+    jsi::Runtime& rt,
+    JSArgT&& value,
+    const std::shared_ptr<CallInvoker>& /*unused*/)
+    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
+        rt,
+        convert(rt, std::forward<JSArgT>(value)))) {
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
+      rt, convert(rt, std::forward<JSArgT>(value)));
+}
+
+template <typename ReturnT, typename JSArgT>
+auto fromJs(
+    jsi::Runtime& rt,
+    JSArgT&& value,
+    const std::shared_ptr<CallInvoker>& jsInvoker)
+    -> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
+        rt,
+        convert(rt, std::forward<JSArgT>(value)),
+        jsInvoker)) {
+  return Bridging<remove_cvref_t<ReturnT>>::fromJs(
+      rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker);
+}
+
+template <typename T>
+  requires is_jsi_v<T>
+auto toJs(
+    jsi::Runtime& rt,
+    T&& value,
+    const std::shared_ptr<CallInvoker>& = nullptr) -> remove_cvref_t<T> {
+  return convert(rt, std::forward<T>(value));
+}
+
+template <typename T>
+auto toJs(
+    jsi::Runtime& rt,
+    T&& value,
+    const std::shared_ptr<CallInvoker>& = nullptr)
+    -> decltype(Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value))) {
+  return Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value));
+}
+
+template <typename T>
+auto toJs(
+    jsi::Runtime& rt,
+    T&& value,
+    const std::shared_ptr<CallInvoker>& jsInvoker)
+    -> decltype(Bridging<bridging_t<T>>::toJs(
+        rt,
+        std::forward<T>(value),
+        jsInvoker)) {
+  return Bridging<bridging_t<T>>::toJs(rt, std::forward<T>(value), jsInvoker);
+}
+
+template <typename, typename = jsi::Value, typename = void>
+inline constexpr bool supportsFromJs = false;
+
+template <typename T, typename Arg>
+inline constexpr bool supportsFromJs<
+    T,
+    Arg,
+    std::void_t<decltype(fromJs<T>(
+        std::declval<jsi::Runtime&>(),
+        std::declval<Arg>(),
+        nullptr))>> = true;
+
+template <typename T>
+inline constexpr bool supportsFromJs<
+    T,
+    jsi::Value,
+    std::void_t<decltype(fromJs<T>(
+        std::declval<jsi::Runtime&>(),
+        std::declval<jsi::Value>(),
+        nullptr))>> = true;
+
+template <typename, typename = jsi::Value, typename = void>
+inline constexpr bool supportsToJs = false;
+
+template <typename JSReturnT, typename ReturnT>
+inline constexpr bool supportsToJs<
+    JSReturnT,
+    ReturnT,
+    std::void_t<decltype(toJs(
+        std::declval<jsi::Runtime&>(),
+        std::declval<JSReturnT>(),
+        nullptr))>> =
+    std::is_convertible_v<
+        decltype(toJs(
+            std::declval<jsi::Runtime&>(),
+            std::declval<JSReturnT>(),
+            nullptr)),
+        ReturnT>;
+
+template <typename ReturnT>
+inline constexpr bool supportsToJs<
+    ReturnT,
+    jsi::Value,
+    std::void_t<decltype(toJs(
+        std::declval<jsi::Runtime&>(),
+        std::declval<ReturnT>(),
+        nullptr))>> =
+    std::is_convertible_v<
+        decltype(toJs(
+            std::declval<jsi::Runtime&>(),
+            std::declval<ReturnT>(),
+            nullptr)),
+        jsi::Value>;
+
+} // namespace bridging
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Bool.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<bool> {
+  static bool fromJs(jsi::Runtime&, const jsi::Value& value) {
+    return value.asBool();
+  }
+
+  static bool toJs(jsi::Runtime& /*unused*/, bool value) {
+    return value;
+  }
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Bridging.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/AString.h>
+#include <react/bridging/Array.h>
+#include <react/bridging/Bool.h>
+#include <react/bridging/Class.h>
+#include <react/bridging/Dynamic.h>
+#include <react/bridging/Error.h>
+#include <react/bridging/EventEmitter.h>
+#include <react/bridging/Function.h>
+#include <react/bridging/HighResTimeStamp.h>
+#include <react/bridging/Number.h>
+#include <react/bridging/Object.h>
+#include <react/bridging/Promise.h>
+#include <react/bridging/Value.h>

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/CallbackWrapper.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#include <react/bridging/LongLivedObject.h>
+
+namespace facebook::react {
+
+class CallInvoker;
+
+// Helper for passing jsi::Function arg to other methods.
+class CallbackWrapper : public LongLivedObject {
+ private:
+  CallbackWrapper(
+      jsi::Function&& callback,
+      jsi::Runtime& runtime,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : LongLivedObject(runtime),
+        callback_(std::move(callback)),
+        jsInvoker_(std::move(jsInvoker)) {}
+
+  jsi::Function callback_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+ public:
+  static std::weak_ptr<CallbackWrapper> createWeak(
+      jsi::Function&& callback,
+      jsi::Runtime& runtime,
+      std::shared_ptr<CallInvoker> jsInvoker) {
+    auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
+        std::move(callback), runtime, std::move(jsInvoker)));
+    LongLivedObjectCollection::get(runtime).add(wrapper);
+    return wrapper;
+  }
+
+  // Delete the enclosed jsi::Function
+  void destroy() {
+    allowRelease();
+  }
+
+  jsi::Function& callback() noexcept {
+    return callback_;
+  }
+
+  jsi::Runtime& runtime() noexcept {
+    return runtime_;
+  }
+
+  CallInvoker& jsInvoker() noexcept {
+    return *(jsInvoker_);
+  }
+
+  std::shared_ptr<CallInvoker> jsInvokerPtr() noexcept {
+    return jsInvoker_;
+  }
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Class.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react::bridging {
+
+template <
+    typename JSReturnT,
+    typename ClassT,
+    typename ReturnT,
+    typename... ArgsT,
+    typename... JSArgsT>
+JSReturnT callFromJs(
+    jsi::Runtime& rt,
+    ReturnT (ClassT::*method)(jsi::Runtime&, ArgsT...),
+    const std::shared_ptr<CallInvoker>& jsInvoker,
+    ClassT* instance,
+    JSArgsT&&... args) {
+  static_assert(
+      sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
+  static_assert(
+      (supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
+
+  if constexpr (std::is_void_v<JSReturnT>) {
+    (instance->*method)(
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+
+  } else if constexpr (std::is_void_v<ReturnT>) {
+    static_assert(
+        std::is_same_v<JSReturnT, jsi::Value>,
+        "Void functions may only return undefined");
+
+    (instance->*method)(
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+    return jsi::Value();
+
+  } else if constexpr (
+      is_jsi_v<JSReturnT> || supportsToJs<ReturnT, JSReturnT>) {
+    static_assert(supportsToJs<ReturnT, JSReturnT>, "Incompatible return type");
+
+    return toJs(
+        rt,
+        (instance->*method)(
+            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
+        jsInvoker);
+  } else if constexpr (is_optional_jsi_v<JSReturnT>) {
+    static_assert(
+        is_optional_v<ReturnT>
+            ? supportsToJs<
+                  typename ReturnT::value_type,
+                  typename JSReturnT::value_type>
+            : supportsToJs<ReturnT, typename JSReturnT::value_type>,
+        "Incompatible return type");
+
+    auto result = toJs(
+        rt,
+        (instance->*method)(
+            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
+        jsInvoker);
+
+    if constexpr (std::is_same_v<decltype(result), jsi::Value>) {
+      if (result.isNull() || result.isUndefined()) {
+        return std::nullopt;
+      }
+    }
+
+    return convert(rt, std::move(result));
+  } else {
+    static_assert(
+        std::is_convertible_v<ReturnT, JSReturnT>, "Incompatible return type");
+    return (instance->*method)(
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
+  }
+}
+
+template <typename ReturnT, typename... ArgsT>
+constexpr size_t getParameterCount(ReturnT (*)(ArgsT...)) {
+  return sizeof...(ArgsT);
+}
+
+template <typename Class, typename ReturnT, typename... ArgsT>
+constexpr size_t getParameterCount(ReturnT (Class::*)(ArgsT...)) {
+  return sizeof...(ArgsT);
+}
+
+} // namespace facebook::react::bridging

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Convert.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <optional>
+#include <type_traits>
+
+namespace facebook::react::bridging {
+
+// std::remove_cvref_t is not available until C++20.
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template <typename T>
+inline constexpr bool is_jsi_v =
+    std::is_same_v<jsi::Value, remove_cvref_t<T>> ||
+    std::is_same_v<jsi::String, remove_cvref_t<T>> ||
+    std::is_base_of_v<jsi::Object, remove_cvref_t<T>>;
+
+template <typename>
+struct is_optional : std::false_type {};
+
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_optional_v = is_optional<T>::value;
+
+template <typename T, typename = void>
+inline constexpr bool is_optional_jsi_v = false;
+
+template <typename T>
+inline constexpr bool
+    is_optional_jsi_v<T, typename std::enable_if_t<is_optional_v<T>>> =
+        is_jsi_v<typename T::value_type>;
+
+template <typename T>
+struct Converter;
+
+template <typename T>
+struct ConverterBase {
+  using BaseT = remove_cvref_t<T>;
+
+  ConverterBase(jsi::Runtime& rt, T&& value)
+      : rt_(rt), value_(std::forward<T>(value)) {}
+
+  operator BaseT() && {
+    if constexpr (std::is_lvalue_reference_v<T>) {
+      // Copy the reference into a Value that then can be moved from.
+      auto value = jsi::Value(rt_, value_);
+
+      if constexpr (std::is_same_v<BaseT, jsi::Value>) {
+        return std::move(value);
+      } else if constexpr (std::is_same_v<BaseT, jsi::String>) {
+        return std::move(value).getString(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Object>) {
+        return std::move(value).getObject(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Array>) {
+        return std::move(value).getObject(rt_).getArray(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Function>) {
+        return std::move(value).getObject(rt_).getFunction(rt_);
+      }
+    } else {
+      return std::move(value_);
+    }
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<
+          std::is_lvalue_reference_v<T> &&
+              // Ensure non-reference type can be converted to the desired type.
+              std::is_convertible_v<Converter<BaseT>, U>,
+          int> = 0>
+  operator U() && {
+    return Converter<BaseT>(rt_, std::move(*this).operator BaseT());
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<is_jsi_v<T> && std::is_same_v<U, jsi::Value>, int> = 0>
+  operator U() && = delete; // Prevent unwanted upcasting of JSI values.
+
+ protected:
+  jsi::Runtime& rt_;
+  T value_;
+};
+
+template <typename T>
+struct Converter : public ConverterBase<T> {
+  using ConverterBase<T>::ConverterBase;
+};
+
+template <>
+struct Converter<jsi::Value> : public ConverterBase<jsi::Value> {
+  using ConverterBase<jsi::Value>::ConverterBase;
+
+  operator jsi::String() && {
+    return std::move(value_).asString(rt_);
+  }
+
+  operator jsi::Object() && {
+    return std::move(value_).asObject(rt_);
+  }
+
+  operator jsi::Array() && {
+    return std::move(value_).asObject(rt_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asObject(rt_).asFunction(rt_);
+  }
+};
+
+template <>
+struct Converter<jsi::Object> : public ConverterBase<jsi::Object> {
+  using ConverterBase<jsi::Object>::ConverterBase;
+
+  operator jsi::Array() && {
+    return std::move(value_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asFunction(rt_);
+  }
+};
+
+template <typename T>
+struct Converter<std::optional<T>> : public ConverterBase<jsi::Value> {
+  Converter(jsi::Runtime& rt, std::optional<T> value)
+      : ConverterBase(rt, value ? std::move(*value) : jsi::Value::null()) {}
+
+  operator std::optional<T>() && {
+    if (value_.isNull() || value_.isUndefined()) {
+      return {};
+    }
+    return std::move(value_);
+  }
+};
+
+template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+auto convert(jsi::Runtime& rt, T&& value) {
+  return Converter<T>(rt, std::forward<T>(value));
+}
+
+template <
+    typename T,
+    std::enable_if_t<is_jsi_v<T> || std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime& rt, std::optional<T> value) {
+  return Converter<std::optional<T>>(rt, std::move(value));
+}
+
+template <typename T, std::enable_if_t<std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime& /*rt*/, T&& value) {
+  return value;
+}
+
+template <typename T>
+auto convert(jsi::Runtime& /*rt*/, Converter<T>&& converter) {
+  return std::move(converter);
+}
+
+} // namespace facebook::react::bridging

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Dynamic.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<folly::dynamic> {
+  static folly::dynamic fromJs(jsi::Runtime& rt, const jsi::Value& value) {
+    return jsi::dynamicFromValue(rt, value);
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, const folly::dynamic& value) {
+    return jsi::valueFromDynamic(rt, value);
+  }
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64/Headers/react/bridging/Error.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react {
+
+class Error {
+ public:
+  // TODO (T114055466): Retain stack trace (at least caller location)
+  Error(std::string message) : message_(std::move(message)) {}
+
+  Error(const char* message) : Error(std::string(message)) {}
+
+  const std::string& message() const {
+    return message_;
+  }
+
+ private:
+  std::string message_;
+};
+
+template <>
+struct Bridging<jsi::JSError> {
+  static jsi::JSError fromJs(jsi::Runtime& rt, const jsi::Value& value) {
+    return jsi::JSError(rt, jsi::Value(rt, value));
+  }
+
+  static jsi::JSError fromJs(jsi::Runtime& rt, jsi::Value&& value) {
+    return jsi::JSError(rt, std::move(value));
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, std::string message) {
+    return jsi::Value(rt, jsi::JSError(rt, std::move(message)).value());
+  }
+};
+
+template <>
+struct Bridging<Error> {
+  static jsi::Value toJs(jsi::Runtime& rt, const Error& error) {
+    return jsi::Value(rt, jsi::JSError(rt, error.message()).value());
+  }
+};
+
+} // namespace facebook::react