@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/simulator/Headers/react/featureflags/ReactNativeFeatureFlagsOverridesOSSStable.h

@@ -0,0 +1,33 @@
+/*
+ * 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/featureflags/ReactNativeFeatureFlagsDefaults.h>
+
+namespace facebook::react {
+
+class ReactNativeFeatureFlagsOverridesOSSStable
+    : public ReactNativeFeatureFlagsDefaults {
+ public:
+  bool enableBridgelessArchitecture() override {
+    return true;
+  }
+  bool enableFabricRenderer() override {
+    return true;
+  }
+  bool useTurboModules() override {
+    return true;
+  }
+  bool useNativeViewConfigsInBridgelessMode() override {
+    return true;
+  }
+  bool useShadowNodeStateOnClone() override {
+    return true;
+  }
+};
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/featureflags/ReactNativeFeatureFlagsProvider.h

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ *
+ * @generated SignedSource<<2387ed12fe46fb5b606ad13a17511f03>>
+ */
+
+/**
+ * IMPORTANT: Do NOT modify this file directly.
+ *
+ * To change the definition of the flags, edit
+ *   packages/react-native/scripts/featureflags/ReactNativeFeatureFlags.config.js.
+ *
+ * To regenerate this code, run the following script from the repo root:
+ *   yarn featureflags --update
+ */
+
+#pragma once
+
+namespace facebook::react {
+
+class ReactNativeFeatureFlagsProvider {
+ public:
+  virtual ~ReactNativeFeatureFlagsProvider() = default;
+
+  virtual bool commonTestFlag() = 0;
+  virtual bool animatedShouldSignalBatch() = 0;
+  virtual bool cxxNativeAnimatedEnabled() = 0;
+  virtual bool cxxNativeAnimatedRemoveJsSync() = 0;
+  virtual bool disableMainQueueSyncDispatchIOS() = 0;
+  virtual bool disableMountItemReorderingAndroid() = 0;
+  virtual bool disableTextLayoutManagerCacheAndroid() = 0;
+  virtual bool enableAccessibilityOrder() = 0;
+  virtual bool enableAccumulatedUpdatesInRawPropsAndroid() = 0;
+  virtual bool enableAndroidTextMeasurementOptimizations() = 0;
+  virtual bool enableBridgelessArchitecture() = 0;
+  virtual bool enableCppPropsIteratorSetter() = 0;
+  virtual bool enableCustomFocusSearchOnClippedElementsAndroid() = 0;
+  virtual bool enableDestroyShadowTreeRevisionAsync() = 0;
+  virtual bool enableDoubleMeasurementFixAndroid() = 0;
+  virtual bool enableEagerRootViewAttachment() = 0;
+  virtual bool enableFabricLogs() = 0;
+  virtual bool enableFabricRenderer() = 0;
+  virtual bool enableFixForParentTagDuringReparenting() = 0;
+  virtual bool enableFontScaleChangesUpdatingLayout() = 0;
+  virtual bool enableIOSTextBaselineOffsetPerLine() = 0;
+  virtual bool enableIOSViewClipToPaddingBox() = 0;
+  virtual bool enableInteropViewManagerClassLookUpOptimizationIOS() = 0;
+  virtual bool enableLayoutAnimationsOnAndroid() = 0;
+  virtual bool enableLayoutAnimationsOnIOS() = 0;
+  virtual bool enableMainQueueCoordinatorOnIOS() = 0;
+  virtual bool enableMainQueueModulesOnIOS() = 0;
+  virtual bool enableModuleArgumentNSNullConversionIOS() = 0;
+  virtual bool enableNativeCSSParsing() = 0;
+  virtual bool enableNetworkEventReporting() = 0;
+  virtual bool enableNewBackgroundAndBorderDrawables() = 0;
+  virtual bool enablePreparedTextLayout() = 0;
+  virtual bool enablePropsUpdateReconciliationAndroid() = 0;
+  virtual bool enableResourceTimingAPI() = 0;
+  virtual bool enableSynchronousStateUpdates() = 0;
+  virtual bool enableViewCulling() = 0;
+  virtual bool enableViewRecycling() = 0;
+  virtual bool enableViewRecyclingForText() = 0;
+  virtual bool enableViewRecyclingForView() = 0;
+  virtual bool enableVirtualViewDebugFeatures() = 0;
+  virtual bool enableVirtualViewRenderState() = 0;
+  virtual bool enableVirtualViewWindowFocusDetection() = 0;
+  virtual bool fixMappingOfEventPrioritiesBetweenFabricAndReact() = 0;
+  virtual bool fuseboxEnabledRelease() = 0;
+  virtual bool fuseboxNetworkInspectionEnabled() = 0;
+  virtual bool hideOffscreenVirtualViewsOnIOS() = 0;
+  virtual double preparedTextCacheSize() = 0;
+  virtual bool preventShadowTreeCommitExhaustion() = 0;
+  virtual bool traceTurboModulePromiseRejectionsOnAndroid() = 0;
+  virtual bool updateRuntimeShadowNodeReferencesOnCommit() = 0;
+  virtual bool useAlwaysAvailableJSErrorHandling() = 0;
+  virtual bool useFabricInterop() = 0;
+  virtual bool useNativeEqualsInNativeReadableArrayAndroid() = 0;
+  virtual bool useNativeTransformHelperAndroid() = 0;
+  virtual bool useNativeViewConfigsInBridgelessMode() = 0;
+  virtual bool useOptimizedEventBatchingOnAndroid() = 0;
+  virtual bool useRawPropsJsiValue() = 0;
+  virtual bool useShadowNodeStateOnClone() = 0;
+  virtual bool useTurboModuleInterop() = 0;
+  virtual bool useTurboModules() = 0;
+  virtual double virtualViewPrerenderRatio() = 0;
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/ContextContainer.h

@@ -0,0 +1,110 @@
+/*
+ * 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 <memory>
+#include <mutex>
+#include <optional>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+
+#include <react/debug/flags.h>
+#include <react/debug/react_native_assert.h>
+
+namespace facebook::react {
+
+/*
+ * General purpose dependency injection container.
+ * Instance types must be copyable.
+ */
+class ContextContainer final {
+ public:
+  using Shared = std::shared_ptr<const ContextContainer>;
+
+  /*
+   * Registers an instance of the particular type `T` in the container
+   * using the provided `key`. Only one instance can be registered per key.
+   * The method does nothing if given `key` already exists in the container.
+   *
+   * Convention is to use the plain base class name for the key, so for
+   * example if the type `T` is `std::shared_ptr<const ReactNativeConfig>`,
+   * then one would use `"ReactNativeConfig"` for the `key`, even if the
+   * instance is actually a `shared_ptr` of derived class
+   *`ReactNativeConfig`.
+   */
+  template <typename T>
+  void insert(const std::string& key, const T& instance) const {
+    std::unique_lock lock(mutex_);
+
+    instances_.insert({key, std::make_shared<T>(instance)});
+  }
+
+  /*
+   * Removes an instance stored for a given `key`.
+   * Does nothing if the instance was not found.
+   */
+  void erase(const std::string& key) const {
+    std::unique_lock lock(mutex_);
+
+    instances_.erase(key);
+  }
+
+  /*
+   * Updates the container with values from a given container.
+   * Values with keys that already exist in the container will be replaced with
+   * values from the given container.
+   */
+  void update(const ContextContainer& contextContainer) const {
+    std::unique_lock lock(mutex_);
+
+    for (const auto& pair : contextContainer.instances_) {
+      instances_.erase(pair.first);
+      instances_.insert(pair);
+    }
+  }
+
+  /*
+   * Returns a previously registered instance of the particular type `T`
+   * for `key`.
+   * Throws an exception if the instance could not be found.
+   */
+  template <typename T>
+  T at(const std::string& key) const {
+    std::shared_lock lock(mutex_);
+
+    react_native_assert(
+        instances_.find(key) != instances_.end() &&
+        "ContextContainer doesn't have an instance for given key.");
+    return *static_cast<T*>(instances_.at(key).get());
+  }
+
+  /*
+   * Returns a (wrapped in an optional) previously registered instance of
+   * the particular type `T` for given `key`.
+   * Returns an empty optional if the instance could not be found.
+   */
+  template <typename T>
+  std::optional<T> find(const std::string& key) const {
+    std::shared_lock lock(mutex_);
+
+    auto iterator = instances_.find(key);
+    if (iterator == instances_.end()) {
+      return {};
+    }
+
+    return *static_cast<T*>(iterator->second.get());
+  }
+
+ private:
+  mutable std::shared_mutex mutex_;
+  // Protected by mutex_`.
+  mutable std::unordered_map<std::string, std::shared_ptr<void>> instances_;
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/FloatComparison.h

@@ -0,0 +1,23 @@
+/*
+ * 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 <cmath>
+
+namespace facebook::react {
+
+constexpr float kDefaultEpsilon = 0.005f;
+
+template <typename T>
+inline bool
+floatEquality(T a, T b, T epsilon = static_cast<T>(kDefaultEpsilon)) {
+  return (std::isnan(a) && std::isnan(b)) ||
+      (!std::isnan(a) && !std::isnan(b) && std::abs(a - b) < epsilon);
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/ManagedObjectWrapper.h

@@ -0,0 +1,80 @@
+/*
+ * 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/debug/react_native_assert.h>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#if defined(__OBJC__) && defined(__cplusplus)
+#if TARGET_OS_MAC
+
+#include <memory>
+
+#import <Foundation/Foundation.h>
+
+@interface RCTInternalGenericWeakWrapper : NSObject
+@property (nonatomic, weak) id object;
+@end
+
+namespace facebook::react {
+
+namespace detail {
+
+/*
+ * A custom deleter used for the deallocation of Objective-C managed objects.
+ * To be used only by `wrapManagedObject`.
+ */
+void wrappedManagedObjectDeleter(void *cfPointer) noexcept;
+
+} // namespace detail
+
+/*
+ * `wrapManagedObject` and `unwrapManagedObject` are wrapper functions that
+ * convert ARC-managed objects into `std::shared_ptr<void>` and vice-versa. It's
+ * a very useful mechanism when we need to pass Objective-C objects through pure
+ * C++ code, pass blocks into C++ lambdas, and so on.
+ *
+ * The idea behind this mechanism is quite simple but tricky: When we
+ * instantiate a C++ shared pointer for a managed object, we practically call
+ * `CFRetain` for it once and then we represent this single retaining operation
+ * as a counter inside the shared pointer; when the counter became zero, we call
+ * `CFRelease` on the object. In this model, one bump of ARC-managed counter is
+ * represented as multiple bumps of C++ counter, so we can have multiple
+ * counters for the same object that form some kind of counters tree.
+ */
+inline std::shared_ptr<void> wrapManagedObject(id object) noexcept
+{
+  return std::shared_ptr<void>((__bridge_retained void *)object, detail::wrappedManagedObjectDeleter);
+}
+
+inline id unwrapManagedObject(const std::shared_ptr<void> &object) noexcept
+{
+  return (__bridge id)object.get();
+}
+
+inline std::shared_ptr<void> wrapManagedObjectWeakly(id object) noexcept
+{
+  RCTInternalGenericWeakWrapper *weakWrapper = [RCTInternalGenericWeakWrapper new];
+  weakWrapper.object = object;
+  return wrapManagedObject(weakWrapper);
+}
+
+inline id unwrapManagedObjectWeakly(const std::shared_ptr<void> &object) noexcept
+{
+  RCTInternalGenericWeakWrapper *weakWrapper = (RCTInternalGenericWeakWrapper *)unwrapManagedObject(object);
+  react_native_assert(weakWrapper && "`RCTInternalGenericWeakWrapper` instance must not be `nil`.");
+  return weakWrapper.object;
+}
+
+} // namespace facebook::react
+
+#endif
+#endif

package/build/xcframework/simulator/Headers/react/utils/OnScopeExit.h

@@ -0,0 +1,36 @@
+/*
+ * 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 <utility>
+
+namespace facebook::react {
+
+template <typename Lambda>
+class OnScopeExit {
+ public:
+  explicit OnScopeExit(const Lambda&& lambda) noexcept
+      : lambda_(std::move(lambda)) {}
+
+  // Non-movable
+  OnScopeExit(const OnScopeExit&) = delete;
+  OnScopeExit(OnScopeExit&&) = delete;
+
+  // Non-copyable
+  OnScopeExit& operator=(const OnScopeExit&) = delete;
+  OnScopeExit& operator=(OnScopeExit&&) = delete;
+
+  ~OnScopeExit() noexcept {
+    lambda_();
+  }
+
+ private:
+  Lambda lambda_;
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/PackTraits.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <type_traits>
+
+namespace facebook::react::traits {
+
+template <typename ExpectedT>
+static constexpr bool containsType() {
+  return false;
+}
+
+template <typename ExpectedT, typename FirstT, typename... RestT>
+static constexpr bool containsType() {
+  if constexpr (sizeof...(RestT) > 0) {
+    return std::is_same_v<ExpectedT, FirstT> ||
+        containsType<ExpectedT, RestT...>();
+  } else {
+    return std::is_same_v<ExpectedT, FirstT>;
+  }
+}
+
+} // namespace facebook::react::traits

package/build/xcframework/simulator/Headers/react/utils/RunLoopObserver.h

@@ -0,0 +1,125 @@
+/*
+ * 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 <atomic>
+#include <functional>
+#include <memory>
+
+namespace facebook::react {
+
+/*
+ * A cross-platform abstraction for observing a run loop life cycle.
+ */
+class RunLoopObserver {
+ public:
+  /*
+   * The concept of an owner.
+   * A run loop observer normally observes a run loop running on a different
+   * thread. That implies that this other thread (the run loop thread) will call
+   * methods of this class owned by some other thread. To make it safe, we need
+   * to ensure that at the moment of the calling the observer still exists. To
+   * do so, we use an owner object (a weak pointer) that must retain (possibly
+   * indirectly) the observer. The platform-specific code should convert the
+   * weak pointer (owner) to a strong one right before calling the observer,
+   * ensuring the safety of calling; right after the call, the strong pointer
+   * should be safely released.
+   *
+   * Note, in the case when the pointer to the actual owner will be available
+   * later, only after calling the constructor of the class, the caller can
+   * create a dummy pointer beforehand and then merge it (using
+   * `shared_ptr<X>(shared_ptr<Y> const &, X *)`) with the actual one (sharing
+   * the control block).
+   */
+  using Owner = std::shared_ptr<const void>;
+  using WeakOwner = std::weak_ptr<const void>;
+
+  /*
+   * Run loop activity stages which run loop observers can be observe.
+   */
+  enum Activity : int32_t {
+    None = 0,
+    BeforeWaiting = 1 << 0,
+    AfterWaiting = 1 << 1,
+  };
+
+  /*
+   * A delegate interface.
+   */
+  class Delegate {
+   public:
+    /*
+     * Called on every run loop tick at moments corresponding to requested
+     * activities.
+     *
+     * A platform-specific implementation guarantees that the owner pointer
+     * is retained during this call.
+     * Will be called on the thread associated with the run loop.
+     */
+    virtual void activityDidChange(const Delegate* delegate, Activity activity)
+        const noexcept = 0;
+
+    virtual ~Delegate() noexcept = default;
+  };
+
+  using Factory = std::function<std::unique_ptr<RunLoopObserver>(
+      Activity activities,
+      const WeakOwner& owner)>;
+
+  /*
+   * Constructs a run loop observer.
+   */
+  RunLoopObserver(Activity activities, WeakOwner owner) noexcept;
+  virtual ~RunLoopObserver() noexcept = default;
+
+  /*
+   * Sets the delegate.
+   * Must be called just once.
+   */
+  void setDelegate(const Delegate* delegate) const noexcept;
+
+  /*
+   * Enables or disables run loop observing.
+   * It can be used to save CPU cycles during periods of time when observing
+   * is not required.
+   * A newly constructed run time observer is initially disabled.
+   */
+  void enable() const noexcept;
+  void disable() const noexcept;
+
+  /*
+   * Returns true if called on a thread associated with the run loop.
+   * Must be implemented in subclasses.
+   */
+  virtual bool isOnRunLoopThread() const noexcept = 0;
+
+  /*
+   * Returns an owner associated with the observer.
+   * It might be useful to ensure the safety of consequent asynchronous calls.
+   */
+  WeakOwner getOwner() const noexcept;
+
+ protected:
+  /*
+   * Must be implemented in subclasses.
+   */
+  virtual void startObserving() const noexcept = 0;
+  virtual void stopObserving() const noexcept = 0;
+
+  /*
+   * Called by subclasses to generate a call on a delegate.
+   */
+  void activityDidChange(Activity activity) const noexcept;
+
+  const Activity activities_{};
+  const WeakOwner owner_;
+  mutable const Delegate* delegate_{nullptr};
+  mutable std::atomic<bool> enabled_{false};
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/SharedFunction.h

@@ -0,0 +1,63 @@
+/*
+ * 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 <functional>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+
+namespace facebook::react {
+
+/*
+ * `SharedFunction` implements a pattern of a shared callable object that
+ * contains the same executable inside. It's similar to  `std::function` with
+ * one important difference: when the object is copied, the stored function (and
+ * captured values) are shared between instances (not copied). `SharedFunction`
+ * can be stored inside `std::function` because it's callable. It useful in some
+ * scenarios, such as:
+ * - When captured by `std::function` arguments are not copyable;
+ * - When we need to replace the content of the callable later on the go.
+ */
+template <typename... ArgumentT>
+class SharedFunction {
+  using T = void(ArgumentT...);
+
+  struct Pair {
+    Pair(std::function<T>&& function) : function(std::move(function)) {}
+    std::function<T> function;
+    std::shared_mutex mutex{};
+  };
+
+ public:
+  SharedFunction(std::function<T>&& function = nullptr)
+      : pair_(std::make_shared<Pair>(std::move(function))) {}
+
+  SharedFunction(const SharedFunction& other) = default;
+  SharedFunction(SharedFunction&& other) noexcept = default;
+
+  SharedFunction& operator=(const SharedFunction& other) = default;
+  SharedFunction& operator=(SharedFunction&& other) noexcept = default;
+
+  void assign(std::function<T> function) const {
+    std::unique_lock lock(pair_->mutex);
+    pair_->function = function;
+  }
+
+  void operator()(ArgumentT... args) const {
+    std::shared_lock lock(pair_->mutex);
+    if (pair_->function) {
+      pair_->function(args...);
+    }
+  }
+
+ private:
+  std::shared_ptr<Pair> pair_;
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/SimpleThreadSafeCache.h

@@ -0,0 +1,88 @@
+/*
+ * 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 <concepts>
+#include <list>
+#include <mutex>
+#include <unordered_map>
+
+namespace facebook::react {
+
+template <typename GeneratorT, typename ValueT>
+concept CacheGeneratorFunction = std::invocable<GeneratorT> &&
+    std::same_as<std::invoke_result_t<GeneratorT>, ValueT>;
+
+/*
+ * Simple thread-safe LRU cache.
+ *
+ * TODO T228961279: The maxSize template parameter should be removed, since it
+ * may be overriden by the constructor.
+ */
+template <typename KeyT, typename ValueT, int maxSize>
+class SimpleThreadSafeCache {
+ public:
+  SimpleThreadSafeCache() : maxSize_(maxSize) {}
+  SimpleThreadSafeCache(unsigned long size) : maxSize_{size} {}
+
+  /*
+   * Returns a value from the map with a given key.
+   * If the value wasn't found in the cache, constructs the value using given
+   * generator function, stores it inside a cache and returns it.
+   * Can be called from any thread.
+   */
+  ValueT get(const KeyT& key, CacheGeneratorFunction<ValueT> auto generator)
+      const {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (auto it = map_.find(key); it != map_.end()) {
+      // Move accessed item to front of list
+      list_.splice(list_.begin(), list_, it->second);
+      return it->second->second;
+    }
+
+    auto value = generator();
+    // Add new value to front of list and map
+    list_.emplace_front(key, value);
+    map_[key] = list_.begin();
+    if (list_.size() > maxSize_) {
+      // Evict least recently used item (back of list)
+      map_.erase(list_.back().first);
+      list_.pop_back();
+    }
+    return value;
+  }
+
+  /*
+   * Returns a value from the map with a given key.
+   * If the value wasn't found in the cache, returns empty optional.
+   * Can be called from any thread.
+   */
+  std::optional<ValueT> get(const KeyT& key) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (auto it = map_.find(key); it != map_.end()) {
+      // Move accessed item to front of list
+      list_.splice(list_.begin(), list_, it->second);
+      return it->second->second;
+    }
+
+    return ValueT{};
+  }
+
+ private:
+  using EntryT = std::pair<KeyT, ValueT>;
+  using iterator = typename std::list<EntryT>::iterator;
+
+  size_t maxSize_;
+  mutable std::mutex mutex_;
+  mutable std::list<EntryT> list_;
+  mutable std::unordered_map<KeyT, iterator> map_;
+};
+
+} // namespace facebook::react