react-native-windows 0.76.3 → 0.77.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -14,7 +14,7 @@
 #include <jsi/jsi.h>
 
 #include <ReactCommon/CallInvoker.h>
-#include <EventEmitter.h> // [Windows #13391]
+#include <react/bridging/EventEmitter.h>
 
 namespace facebook::react {
 
@@ -46,30 +46,33 @@ class TurboModuleBinding;
 /**
  * Base HostObject class for every module to be exposed to JS
  */
-class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
+class JSI_EXPORT TurboModule : public jsi::HostObject {
  public:
   TurboModule(std::string name, std::shared_ptr<CallInvoker> jsInvoker);
 
+  // DO NOT OVERRIDE - it will become final in a future release.
+  // This method provides automatic caching of properties on the TurboModule's
+  // JS representation. To customize lookup of properties, override `create`.
   // Note: keep this method declared inline to avoid conflicts
   // between RTTI and non-RTTI compilation units
-  facebook::jsi::Value get(
-      facebook::jsi::Runtime& runtime,
-      const facebook::jsi::PropNameID& propName) override {
-    {
-      auto prop = create(runtime, propName);
-      // If we have a JS wrapper, cache the result of this lookup
-      // We don't cache misses, to allow for methodMap_ to dynamically be
-      // extended
-      if (jsRepresentation_ && !prop.isUndefined()) {
-        jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
-            runtime, propName, prop);
-      }
-      return prop;
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName)
+      override {
+    auto prop = create(runtime, propName);
+    // If we have a JS wrapper, cache the result of this lookup
+    // We don't cache misses, to allow for methodMap_ to dynamically be
+    // extended
+    // [Windows] Reenable once https://github.com/microsoft/react-native-windows/issues/14128 is fixed
+#ifndef WINAPI_FAMILY
+    if (jsRepresentation_ && !prop.isUndefined()) {
+      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
+          runtime, propName, prop);
     }
+#endif
+    return prop;
   }
 
-  virtual std::vector<facebook::jsi::PropNameID> getPropertyNames(
-      facebook::jsi::Runtime& runtime) override {
+  std::vector<jsi::PropNameID> getPropertyNames(
+      jsi::Runtime& runtime) override {
     std::vector<jsi::PropNameID> result;
     result.reserve(methodMap_.size());
     for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
@@ -84,10 +87,10 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
 
   struct MethodMetadata {
     size_t argCount;
-    facebook::jsi::Value (*invoker)(
-        facebook::jsi::Runtime& rt,
+    jsi::Value (*invoker)(
+        jsi::Runtime& rt,
         TurboModule& turboModule,
-        const facebook::jsi::Value* args,
+        const jsi::Value* args,
         size_t count);
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
@@ -141,13 +144,13 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
     } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
                eventEmitterIter != eventEmitterMap_.end()) {
       return eventEmitterIter->second->get(runtime, jsInvoker_);
+    } else {
+      // Neither Method nor EventEmitter were found, let JS decide what to do
+      return jsi::Value::undefined();
     }
-    // Neither Method nor EventEmitter were not found, let JS decide what to do.
-    return facebook::jsi::Value::undefined();
   }
 
  private:
-  friend class TurboCxxModule;
   friend class TurboModuleBinding;
   std::unique_ptr<jsi::WeakObject> jsRepresentation_;
 };

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/componentregistry/ComponentDescriptorRegistry.cpp

@@ -0,0 +1,150 @@
+/*
+ * 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.
+ */
+
+#include "ComponentDescriptorRegistry.h"
+
+#include "componentNameByReactViewName.h"
+
+#include <react/config/ReactNativeConfig.h>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticComponentDescriptor.h>
+#include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+#include <utility>
+
+namespace facebook::react {
+
+ComponentDescriptorRegistry::ComponentDescriptorRegistry(
+    ComponentDescriptorParameters parameters,
+    const ComponentDescriptorProviderRegistry& providerRegistry,
+    ContextContainer::Shared contextContainer)
+    : parameters_(std::move(parameters)),
+      providerRegistry_(providerRegistry),
+      contextContainer_(std::move(contextContainer)) {}
+
+void ComponentDescriptorRegistry::add(
+    ComponentDescriptorProvider componentDescriptorProvider) const {
+  std::unique_lock lock(mutex_);
+
+  auto componentDescriptor = componentDescriptorProvider.constructor(
+      {parameters_.eventDispatcher,
+       parameters_.contextContainer,
+       componentDescriptorProvider.flavor});
+  react_native_assert(
+      componentDescriptor->getComponentHandle() ==
+      componentDescriptorProvider.handle);
+  react_native_assert(
+      componentDescriptor->getComponentName() ==
+      componentDescriptorProvider.name);
+
+  auto sharedComponentDescriptor = std::shared_ptr<const ComponentDescriptor>(
+      std::move(componentDescriptor));
+  _registryByHandle[componentDescriptorProvider.handle] =
+      sharedComponentDescriptor;
+  _registryByName[componentDescriptorProvider.name] = sharedComponentDescriptor;
+}
+
+void ComponentDescriptorRegistry::registerComponentDescriptor(
+    const SharedComponentDescriptor& componentDescriptor) const {
+  ComponentHandle componentHandle = componentDescriptor->getComponentHandle();
+  _registryByHandle[componentHandle] = componentDescriptor;
+
+  ComponentName componentName = componentDescriptor->getComponentName();
+  _registryByName[componentName] = componentDescriptor;
+}
+
+const ComponentDescriptor& ComponentDescriptorRegistry::at(
+    const std::string& componentName) const {
+  std::shared_lock lock(mutex_);
+
+  auto unifiedComponentName = componentNameByReactViewName(componentName);
+
+  auto it = _registryByName.find(unifiedComponentName);
+  if (it == _registryByName.end()) {
+    lock.unlock();
+    providerRegistry_.request(unifiedComponentName.c_str());
+    lock.lock();
+
+    it = _registryByName.find(unifiedComponentName);
+
+    /*
+     * TODO: T54849676
+     * Uncomment the `assert` after the following block that checks
+     * `_fallbackComponentDescriptor` is no longer needed. The assert assumes
+     * that `componentDescriptorProviderRequest` is always not null and register
+     * some component on every single request.
+     */
+    // assert(it != _registryByName.end());
+  }
+
+  if (it == _registryByName.end()) {
+  // [Windows ##14204
+    auto reactNativeConfig_ =
+        contextContainer_->at<std::shared_ptr<const ReactNativeConfig>>(
+            "ReactNativeConfig");
+    if (reactNativeConfig_->getBool(
+            "react_fabric:enabled_automatic_interop_android")) {
+      auto componentDescriptor = std::make_shared<
+          const UnstableLegacyViewManagerAutomaticComponentDescriptor>(
+          parameters_, unifiedComponentName);
+      registerComponentDescriptor(componentDescriptor);
+      return *_registryByName.find(unifiedComponentName)->second;
+    } else if (_fallbackComponentDescriptor == nullptr) {
+      throw std::invalid_argument(
+          ("Unable to find componentDescriptor for " + unifiedComponentName)
+              .c_str());
+    } else {
+      return *_fallbackComponentDescriptor.get();
+    }
+  // Windows]
+  }
+
+  return *it->second;
+}
+
+const ComponentDescriptor* ComponentDescriptorRegistry::
+    findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
+        ComponentHandle componentHandle) const {
+  std::shared_lock lock(mutex_);
+
+  auto iterator = _registryByHandle.find(componentHandle);
+  if (iterator == _registryByHandle.end()) {
+    return nullptr;
+  }
+
+  return iterator->second.get();
+}
+
+const ComponentDescriptor& ComponentDescriptorRegistry::at(
+    ComponentHandle componentHandle) const {
+  std::shared_lock lock(mutex_);
+
+  return *_registryByHandle.at(componentHandle);
+}
+
+bool ComponentDescriptorRegistry::hasComponentDescriptorAt(
+    ComponentHandle componentHandle) const {
+  std::shared_lock lock(mutex_);
+
+  auto iterator = _registryByHandle.find(componentHandle);
+  return iterator != _registryByHandle.end();
+}
+
+void ComponentDescriptorRegistry::setFallbackComponentDescriptor(
+    const SharedComponentDescriptor& descriptor) {
+  _fallbackComponentDescriptor = descriptor;
+  registerComponentDescriptor(descriptor);
+}
+
+ComponentDescriptor::Shared
+ComponentDescriptorRegistry::getFallbackComponentDescriptor() const {
+  return _fallbackComponentDescriptor;
+}
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/AccessibilityPrimitives.h

@@ -0,0 +1,252 @@
+/*
+ * 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 <cinttypes>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+enum class AccessibilityTraits : uint32_t {
+  None = 0,
+  Button = (1 << 0),
+  Link = (1 << 1),
+  Image = (1 << 2),
+  Selected = (1 << 3),
+  PlaysSound = (1 << 4),
+  KeyboardKey = (1 << 5),
+  StaticText = (1 << 6),
+  SummaryElement = (1 << 7),
+  NotEnabled = (1 << 8),
+  UpdatesFrequently = (1 << 9),
+  SearchField = (1 << 10),
+  StartsMediaSession = (1 << 11),
+  Adjustable = (1 << 12),
+  AllowsDirectInteraction = (1 << 13),
+  CausesPageTurn = (1 << 14),
+  Header = (1 << 15),
+  Switch = (1 << 16),
+  TabBar = (1 << 17),
+};
+
+constexpr enum AccessibilityTraits operator|(
+    const enum AccessibilityTraits lhs,
+    const enum AccessibilityTraits rhs) {
+  return (enum AccessibilityTraits)((uint32_t)lhs | (uint32_t)rhs);
+}
+
+constexpr enum AccessibilityTraits operator&(
+    const enum AccessibilityTraits lhs,
+    const enum AccessibilityTraits rhs) {
+  return (enum AccessibilityTraits)((uint32_t)lhs & (uint32_t)rhs);
+}
+
+struct AccessibilityAction {
+  std::string name{""};
+  std::optional<std::string> label{};
+};
+
+inline static bool operator==(
+    const AccessibilityAction& lhs,
+    const AccessibilityAction& rhs) {
+  return lhs.name == rhs.name && lhs.label == rhs.label;
+}
+
+inline static bool operator!=(
+    const AccessibilityAction& lhs,
+    const AccessibilityAction& rhs) {
+  return !(rhs == lhs);
+}
+
+struct AccessibilityState {
+  bool disabled{false};
+  std::optional<bool> selected{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionItemProvider Implementation
+  bool busy{false};
+  std::optional<bool> expanded{std::nullopt};
+  std::optional<bool> multiselectable{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
+  std::optional<bool> required{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
+  enum { Unchecked, Checked, Mixed, None } checked{None};
+};
+
+constexpr bool operator==(
+    const AccessibilityState& lhs,
+    const AccessibilityState& rhs) {
+  return lhs.disabled == rhs.disabled && lhs.selected == rhs.selected &&
+      lhs.checked == rhs.checked && lhs.busy == rhs.busy &&
+      lhs.expanded == rhs.expanded;
+}
+
+constexpr bool operator!=(
+    const AccessibilityState& lhs,
+    const AccessibilityState& rhs) {
+  return !(rhs == lhs);
+}
+
+struct AccessibilityLabelledBy {
+  std::vector<std::string> value{};
+};
+
+inline static bool operator==(
+    const AccessibilityLabelledBy& lhs,
+    const AccessibilityLabelledBy& rhs) {
+  return lhs.value == rhs.value;
+}
+
+inline static bool operator!=(
+    const AccessibilityLabelledBy& lhs,
+    const AccessibilityLabelledBy& rhs) {
+  return !(lhs == rhs);
+}
+
+struct AccessibilityValue {
+  std::optional<int> min;
+  std::optional<int> max;
+  std::optional<int> now;
+  std::optional<std::string> text{};
+};
+
+constexpr bool operator==(
+    const AccessibilityValue& lhs,
+    const AccessibilityValue& rhs) {
+  return lhs.min == rhs.min && lhs.max == rhs.max && lhs.now == rhs.now &&
+      lhs.text == rhs.text;
+}
+
+constexpr bool operator!=(
+    const AccessibilityValue& lhs,
+    const AccessibilityValue& rhs) {
+  return !(rhs == lhs);
+}
+
+enum class ImportantForAccessibility : uint8_t {
+  Auto,
+  Yes,
+  No,
+  NoHideDescendants,
+};
+
+enum class AccessibilityLiveRegion : uint8_t {
+  None,
+  Polite,
+  Assertive,
+};
+
+enum class AccessibilityRole {
+  None,
+  Button,
+  Dropdownlist,
+  Togglebutton,
+  Link,
+  Search,
+  Image,
+  Keyboardkey,
+  Text,
+  Adjustable,
+  Imagebutton,
+  Header,
+  Summary,
+  Alert,
+  Checkbox,
+  Combobox,
+  Menu,
+  Menubar,
+  Menuitem,
+  Progressbar,
+  Radio,
+  Radiogroup,
+  Scrollbar,
+  Spinbutton,
+  Switch,
+  Tab,
+  Tabbar,
+  Tablist,
+  Timer,
+  List,
+  Toolbar,
+  Grid,
+  Pager,
+  Scrollview,
+  Horizontalscrollview,
+  Viewgroup,
+  Webview,
+  Drawerlayout,
+  Slidingdrawer,
+  Iconmenu,
+};
+
+enum class Role {
+  Alert,
+  Alertdialog,
+  Application,
+  Article,
+  Banner,
+  Button,
+  Cell,
+  Checkbox,
+  Columnheader,
+  Combobox,
+  Complementary,
+  Contentinfo,
+  Definition,
+  Dialog,
+  Directory,
+  Document,
+  Feed,
+  Figure,
+  Form,
+  Grid,
+  Group,
+  Heading,
+  Img,
+  Link,
+  List,
+  Listitem,
+  Log,
+  Main,
+  Marquee,
+  Math,
+  Menu,
+  Menubar,
+  Menuitem,
+  Meter,
+  Navigation,
+  None,
+  Note,
+  Option,
+  Presentation,
+  Progressbar,
+  Radio,
+  Radiogroup,
+  Region,
+  Row,
+  Rowgroup,
+  Rowheader,
+  Scrollbar,
+  Searchbox,
+  Separator,
+  Slider,
+  Spinbutton,
+  Status,
+  Summary,
+  Switch,
+  Tab,
+  Table,
+  Tablist,
+  Tabpanel,
+  Term,
+  Timer,
+  Toolbar,
+  Tooltip,
+  Tree,
+  Treegrid,
+  Treeitem,
+};
+
+} // namespace facebook::react