react-native-platform-components 1.3.0 → 1.5.0

package/react-native.config.js

@@ -6,6 +6,12 @@ module.exports = {
           'MeasuringPCSelectionMenuComponentDescriptor',
           'MeasuringPCDatePickerComponentDescriptor',
           'MeasuringPCSegmentedControlComponentDescriptor',
+          'MeasuringPCButtonComponentDescriptor',
+          'MeasuringPCButtonGroupComponentDescriptor',
+          'MeasuringPCTextFieldComponentDescriptor',
+          'MeasuringPCTabBarComponentDescriptor',
+          'MeasuringPCNavigationRailComponentDescriptor',
+          'MeasuringPCFloatingActionButtonComponentDescriptor',
         ],
         cmakeListsPath: 'src/main/jni/CMakeLists.txt',
       },

package/shared/PCButtonComponentDescriptors-custom.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+// Forward declaration to avoid circular includes
+namespace facebook::react {
+class MeasuringPCButtonShadowNode;
+}
+
+// Include the actual shadow node definition
+#include "PCButtonShadowNode-custom.h"
+
+namespace facebook::react {
+
+/**
+ * Custom component descriptor that uses our measuring shadow node
+ * instead of the generated one.
+ */
+using MeasuringPCButtonComponentDescriptor =
+    ConcreteComponentDescriptor<MeasuringPCButtonShadowNode>;
+
+} // namespace facebook::react

package/shared/PCButtonGroupComponentDescriptors-custom.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+// Forward declaration to avoid circular includes
+namespace facebook::react {
+class MeasuringPCButtonGroupShadowNode;
+}
+
+// Include the actual shadow node definition
+#include "PCButtonGroupShadowNode-custom.h"
+
+namespace facebook::react {
+
+/**
+ * Custom component descriptor that uses our measuring shadow node
+ * instead of the generated one.
+ */
+using MeasuringPCButtonGroupComponentDescriptor =
+    ConcreteComponentDescriptor<MeasuringPCButtonGroupShadowNode>;
+
+} // namespace facebook::react

package/shared/PCButtonGroupShadowNode-custom.cpp

@@ -0,0 +1,48 @@
+#include "PCButtonGroupShadowNode-custom.h"
+
+#include <react/renderer/core/LayoutConstraints.h>
+#include <algorithm>
+
+namespace facebook::react {
+
+Size MeasuringPCButtonGroupShadowNode::measureContent(
+    const LayoutContext& /*layoutContext*/,
+    const LayoutConstraints& layoutConstraints) const {
+
+  // Native measures the actual group and reports its intrinsic size
+  const auto& stateData = this->getStateData();
+  Float measuredW = stateData.frameSize.width;
+  Float measuredH = stateData.frameSize.height;
+
+  const Float fallbackHeight =
+#ifdef __ANDROID__
+      static_cast<Float>(kFallbackHeightAndroid);
+#else
+      static_cast<Float>(kFallbackHeightIOS);
+#endif
+
+  const bool usingFallback = (measuredH <= 0);
+  if (usingFallback) {
+    measuredH = fallbackHeight;
+  }
+  if (measuredW <= 0) {
+    measuredW = static_cast<Float>(kFallbackWidth);
+  }
+
+  const Float kHuge = static_cast<Float>(1.0e9);
+
+  measuredW = std::max<Float>(measuredW, layoutConstraints.minimumSize.width);
+  if (layoutConstraints.maximumSize.width > 0 && layoutConstraints.maximumSize.width < kHuge) {
+    measuredW = std::min<Float>(measuredW, layoutConstraints.maximumSize.width);
+  }
+
+  measuredH = std::max<Float>(measuredH, layoutConstraints.minimumSize.height);
+  // Only clamp to max height if we have real measured data (not fallback)
+  if (!usingFallback && layoutConstraints.maximumSize.height > 0 && layoutConstraints.maximumSize.height < kHuge) {
+    measuredH = std::min<Float>(measuredH, layoutConstraints.maximumSize.height);
+  }
+
+  return Size{measuredW, measuredH};
+}
+
+} // namespace facebook::react

package/shared/PCButtonGroupShadowNode-custom.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+// Only include what we need for the shadow node definition
+// Do NOT include ComponentDescriptors.h here to avoid circular dependency
+#include <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
+#include <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+
+#include "PCButtonGroupState-custom.h"
+
+namespace facebook::react {
+
+extern const char PCButtonGroupComponentName[];
+
+/**
+ * Custom ShadowNode for ButtonGroup that supports Yoga measurement.
+ *
+ * - Native measures the actual group and updates state with frameSize
+ * - measureContent() returns the size from state for proper Yoga layout
+ * - Falls back to platform-specific defaults if state hasn't been set yet
+ */
+class MeasuringPCButtonGroupShadowNode final : public ConcreteViewShadowNode<
+                                          PCButtonGroupComponentName,
+                                          PCButtonGroupProps,
+                                          PCButtonGroupEventEmitter,
+                                          PCButtonGroupStateFrameSize> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // Fallback sizes used when native hasn't reported measurements yet
+  // iOS: a row of small UIButtons
+  static constexpr float kFallbackHeightIOS = 34.0f;
+
+  // Android: small Material 3 buttons (40dp) plus their 4dp touch insets
+  static constexpr float kFallbackHeightAndroid = 48.0f;
+
+  static constexpr float kFallbackWidth = 160.0f;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  /**
+   * Called by Yoga when it needs the intrinsic size of the component.
+   */
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/shared/PCButtonGroupState-custom.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <react/renderer/core/LayoutPrimitives.h>
+#include <memory>
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook::react {
+
+/**
+ * Custom state for ButtonGroup that holds the measured frame size from native.
+ * The native side measures the actual group and communicates the size to
+ * the shadow node for proper Yoga layout.
+ */
+struct PCButtonGroupStateFrameSize {
+  using Shared = std::shared_ptr<const PCButtonGroupStateFrameSize>;
+
+  Size frameSize{}; // {width, height} in points
+
+  PCButtonGroupStateFrameSize() = default;
+
+  explicit PCButtonGroupStateFrameSize(Size size) : frameSize(size) {}
+
+  bool operator==(const PCButtonGroupStateFrameSize& other) const {
+    return frameSize.width == other.frameSize.width &&
+           frameSize.height == other.frameSize.height;
+  }
+
+  bool operator!=(const PCButtonGroupStateFrameSize& other) const {
+    return !(*this == other);
+  }
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+  // Required for Android state serialization
+  PCButtonGroupStateFrameSize(
+      const PCButtonGroupStateFrameSize& previousState,
+      folly::dynamic data)
+      : frameSize(previousState.frameSize) {
+    if (data.isObject()) {
+      if (data.count("width") && data.count("height")) {
+        frameSize.width = static_cast<Float>(data["width"].asDouble());
+        frameSize.height = static_cast<Float>(data["height"].asDouble());
+      }
+    }
+  }
+
+  folly::dynamic getDynamic() const {
+    return folly::dynamic::object("width", frameSize.width)("height", frameSize.height);
+  }
+
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  }
+#endif
+};
+
+} // namespace facebook::react

package/shared/PCButtonShadowNode-custom.cpp

@@ -0,0 +1,48 @@
+#include "PCButtonShadowNode-custom.h"
+
+#include <react/renderer/core/LayoutConstraints.h>
+#include <algorithm>
+
+namespace facebook::react {
+
+Size MeasuringPCButtonShadowNode::measureContent(
+    const LayoutContext& /*layoutContext*/,
+    const LayoutConstraints& layoutConstraints) const {
+
+  // Native measures the actual button and reports its intrinsic size
+  const auto& stateData = this->getStateData();
+  Float measuredW = stateData.frameSize.width;
+  Float measuredH = stateData.frameSize.height;
+
+  const Float fallbackHeight =
+#ifdef __ANDROID__
+      static_cast<Float>(kFallbackHeightAndroid);
+#else
+      static_cast<Float>(kFallbackHeightIOS);
+#endif
+
+  const bool usingFallback = (measuredH <= 0);
+  if (usingFallback) {
+    measuredH = fallbackHeight;
+  }
+  if (measuredW <= 0) {
+    measuredW = static_cast<Float>(kFallbackWidth);
+  }
+
+  const Float kHuge = static_cast<Float>(1.0e9);
+
+  measuredW = std::max<Float>(measuredW, layoutConstraints.minimumSize.width);
+  if (layoutConstraints.maximumSize.width > 0 && layoutConstraints.maximumSize.width < kHuge) {
+    measuredW = std::min<Float>(measuredW, layoutConstraints.maximumSize.width);
+  }
+
+  measuredH = std::max<Float>(measuredH, layoutConstraints.minimumSize.height);
+  // Only clamp to max height if we have real measured data (not fallback)
+  if (!usingFallback && layoutConstraints.maximumSize.height > 0 && layoutConstraints.maximumSize.height < kHuge) {
+    measuredH = std::min<Float>(measuredH, layoutConstraints.maximumSize.height);
+  }
+
+  return Size{measuredW, measuredH};
+}
+
+} // namespace facebook::react

package/shared/PCButtonShadowNode-custom.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+// Only include what we need for the shadow node definition
+// Do NOT include ComponentDescriptors.h here to avoid circular dependency
+#include <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
+#include <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+
+#include "PCButtonState-custom.h"
+
+namespace facebook::react {
+
+extern const char PCButtonComponentName[];
+
+/**
+ * Custom ShadowNode for Button that supports Yoga measurement.
+ *
+ * - Native measures the actual button and updates state with frameSize
+ * - measureContent() returns the size from state for proper Yoga layout
+ * - Falls back to platform-specific defaults if state hasn't been set yet
+ */
+class MeasuringPCButtonShadowNode final : public ConcreteViewShadowNode<
+                                          PCButtonComponentName,
+                                          PCButtonProps,
+                                          PCButtonEventEmitter,
+                                          PCButtonStateFrameSize> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // Fallback sizes used when native hasn't reported measurements yet
+  // iOS UIButton.Configuration small size
+  static constexpr float kFallbackHeightIOS = 34.0f;
+
+  // Android Material 3 small button (40dp) plus its 4dp touch insets
+  static constexpr float kFallbackHeightAndroid = 48.0f;
+
+  static constexpr float kFallbackWidth = 64.0f;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  /**
+   * Called by Yoga when it needs the intrinsic size of the component.
+   */
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/shared/PCButtonState-custom.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <react/renderer/core/LayoutPrimitives.h>
+#include <memory>
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook::react {
+
+/**
+ * Custom state for Button that holds the measured frame size from native.
+ * The native side measures the actual button and communicates the size to
+ * the shadow node for proper Yoga layout.
+ */
+struct PCButtonStateFrameSize {
+  using Shared = std::shared_ptr<const PCButtonStateFrameSize>;
+
+  Size frameSize{}; // {width, height} in points
+
+  PCButtonStateFrameSize() = default;
+
+  explicit PCButtonStateFrameSize(Size size) : frameSize(size) {}
+
+  bool operator==(const PCButtonStateFrameSize& other) const {
+    return frameSize.width == other.frameSize.width &&
+           frameSize.height == other.frameSize.height;
+  }
+
+  bool operator!=(const PCButtonStateFrameSize& other) const {
+    return !(*this == other);
+  }
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+  // Required for Android state serialization
+  PCButtonStateFrameSize(
+      const PCButtonStateFrameSize& previousState,
+      folly::dynamic data)
+      : frameSize(previousState.frameSize) {
+    if (data.isObject()) {
+      if (data.count("width") && data.count("height")) {
+        frameSize.width = static_cast<Float>(data["width"].asDouble());
+        frameSize.height = static_cast<Float>(data["height"].asDouble());
+      }
+    }
+  }
+
+  folly::dynamic getDynamic() const {
+    return folly::dynamic::object("width", frameSize.width)("height", frameSize.height);
+  }
+
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  }
+#endif
+};
+
+} // namespace facebook::react

package/shared/PCFloatingActionButtonComponentDescriptors-custom.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+// Forward declaration to avoid circular includes
+namespace facebook::react {
+class MeasuringPCFloatingActionButtonShadowNode;
+}
+
+// Include the actual shadow node definition
+#include "PCFloatingActionButtonShadowNode-custom.h"
+
+namespace facebook::react {
+
+/**
+ * Custom component descriptor that uses our measuring shadow node
+ * instead of the generated one.
+ */
+using MeasuringPCFloatingActionButtonComponentDescriptor =
+    ConcreteComponentDescriptor<MeasuringPCFloatingActionButtonShadowNode>;
+
+} // namespace facebook::react

package/shared/PCFloatingActionButtonShadowNode-custom.cpp

@@ -0,0 +1,48 @@
+#include "PCFloatingActionButtonShadowNode-custom.h"
+
+#include <react/renderer/core/LayoutConstraints.h>
+#include <algorithm>
+
+namespace facebook::react {
+
+Size MeasuringPCFloatingActionButtonShadowNode::measureContent(
+    const LayoutContext& /*layoutContext*/,
+    const LayoutConstraints& layoutConstraints) const {
+
+  // Native measures the actual button and reports its intrinsic size
+  const auto& stateData = this->getStateData();
+  Float measuredW = stateData.frameSize.width;
+  Float measuredH = stateData.frameSize.height;
+
+  const Float fallbackHeight =
+#ifdef __ANDROID__
+      static_cast<Float>(kFallbackHeightAndroid);
+#else
+      static_cast<Float>(kFallbackHeightIOS);
+#endif
+
+  const bool usingFallback = (measuredH <= 0);
+  if (usingFallback) {
+    measuredH = fallbackHeight;
+  }
+  if (measuredW <= 0) {
+    measuredW = static_cast<Float>(kFallbackWidth);
+  }
+
+  const Float kHuge = static_cast<Float>(1.0e9);
+
+  measuredW = std::max<Float>(measuredW, layoutConstraints.minimumSize.width);
+  if (layoutConstraints.maximumSize.width > 0 && layoutConstraints.maximumSize.width < kHuge) {
+    measuredW = std::min<Float>(measuredW, layoutConstraints.maximumSize.width);
+  }
+
+  measuredH = std::max<Float>(measuredH, layoutConstraints.minimumSize.height);
+  // Only clamp to max height if we have real measured data (not fallback)
+  if (!usingFallback && layoutConstraints.maximumSize.height > 0 && layoutConstraints.maximumSize.height < kHuge) {
+    measuredH = std::min<Float>(measuredH, layoutConstraints.maximumSize.height);
+  }
+
+  return Size{measuredW, measuredH};
+}
+
+} // namespace facebook::react

package/shared/PCFloatingActionButtonShadowNode-custom.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+// Only include what we need for the shadow node definition
+// Do NOT include ComponentDescriptors.h here to avoid circular dependency
+#include <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
+#include <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+
+#include "PCFloatingActionButtonState-custom.h"
+
+namespace facebook::react {
+
+extern const char PCFloatingActionButtonComponentName[];
+
+/**
+ * Custom ShadowNode for FloatingActionButton that supports Yoga measurement.
+ *
+ * - Native measures the button (the extended button in its current state)
+ *   and updates state with frameSize
+ * - measureContent() returns the size from state for proper Yoga layout
+ * - Falls back to platform-specific defaults if state hasn't been set yet
+ */
+class MeasuringPCFloatingActionButtonShadowNode final
+    : public ConcreteViewShadowNode<
+          PCFloatingActionButtonComponentName,
+          PCFloatingActionButtonProps,
+          PCFloatingActionButtonEventEmitter,
+          PCFloatingActionButtonStateFrameSize> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // Fallback size used when native hasn't reported measurements yet: the
+  // regular 56pt / 56dp button
+  static constexpr float kFallbackHeightIOS = 56.0f;
+  static constexpr float kFallbackHeightAndroid = 56.0f;
+  static constexpr float kFallbackWidth = 56.0f;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  /**
+   * Called by Yoga when it needs the intrinsic size of the component.
+   */
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/shared/PCFloatingActionButtonState-custom.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <react/renderer/core/LayoutPrimitives.h>
+#include <memory>
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook::react {
+
+/**
+ * Custom state for FloatingActionButton that holds the measured frame size from native.
+ * The native side measures the actual button and communicates the size to
+ * the shadow node for proper Yoga layout.
+ */
+struct PCFloatingActionButtonStateFrameSize {
+  using Shared = std::shared_ptr<const PCFloatingActionButtonStateFrameSize>;
+
+  Size frameSize{}; // {width, height} in points
+
+  PCFloatingActionButtonStateFrameSize() = default;
+
+  explicit PCFloatingActionButtonStateFrameSize(Size size) : frameSize(size) {}
+
+  bool operator==(const PCFloatingActionButtonStateFrameSize& other) const {
+    return frameSize.width == other.frameSize.width &&
+           frameSize.height == other.frameSize.height;
+  }
+
+  bool operator!=(const PCFloatingActionButtonStateFrameSize& other) const {
+    return !(*this == other);
+  }
+
+#if defined(RN_SERIALIZABLE_STATE) || defined(ANDROID)
+  // Required for Android state serialization
+  PCFloatingActionButtonStateFrameSize(
+      const PCFloatingActionButtonStateFrameSize& previousState,
+      folly::dynamic data)
+      : frameSize(previousState.frameSize) {
+    if (data.isObject()) {
+      if (data.count("width") && data.count("height")) {
+        frameSize.width = static_cast<Float>(data["width"].asDouble());
+        frameSize.height = static_cast<Float>(data["height"].asDouble());
+      }
+    }
+  }
+
+  folly::dynamic getDynamic() const {
+    return folly::dynamic::object("width", frameSize.width)("height", frameSize.height);
+  }
+
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  }
+#endif
+};
+
+} // namespace facebook::react

package/shared/PCNavigationRailComponentDescriptors-custom.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+// Forward declaration to avoid circular includes
+namespace facebook::react {
+class MeasuringPCNavigationRailShadowNode;
+}
+
+// Include the actual shadow node definition
+#include "PCNavigationRailShadowNode-custom.h"
+
+namespace facebook::react {
+
+/**
+ * Component descriptor for NavigationRail. Gives the node the natural width
+ * native reported, as horizontal padding (the way SafeAreaView applies its
+ * insets): a node with children can't have a measure function, and its only
+ * child, the header, is out of the flow.
+ */
+class MeasuringPCNavigationRailComponentDescriptor final
+    : public ConcreteComponentDescriptor<MeasuringPCNavigationRailShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode& shadowNode) const override {
+    auto& layoutableShadowNode = static_cast<YogaLayoutableShadowNode&>(shadowNode);
+    const auto& stateData =
+        static_cast<const MeasuringPCNavigationRailShadowNode::ConcreteState&>(
+            *shadowNode.getState())
+            .getData();
+
+    Float width = stateData.frameSize.width;
+    if (width <= 0) {
+#ifdef __ANDROID__
+      width = MeasuringPCNavigationRailShadowNode::kFallbackWidthAndroid;
+#else
+      width = MeasuringPCNavigationRailShadowNode::kFallbackWidthIOS;
+#endif
+    }
+    layoutableShadowNode.setPadding({width / 2, 0, width / 2, 0});
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

package/shared/PCNavigationRailShadowNode-custom.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+// Only include what we need for the shadow node definition
+// Do NOT include ComponentDescriptors.h here to avoid circular dependency
+#include <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
+#include <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+
+#include "PCNavigationRailState-custom.h"
+
+namespace facebook::react {
+
+extern const char PCNavigationRailComponentName[];
+
+/**
+ * Custom ShadowNode for NavigationRail.
+ *
+ * The rail hosts React children (its header), so it can't be a measured leaf
+ * node like the other components. Native measures the rail and reports its
+ * natural width through state instead, and the component descriptor turns
+ * that width into horizontal padding (see
+ * PCNavigationRailComponentDescriptors-custom.h). The header is absolutely
+ * positioned, so the padding alone gives the node its width; the height is
+ * left to the app's layout.
+ */
+class MeasuringPCNavigationRailShadowNode final
+    : public ConcreteViewShadowNode<
+          PCNavigationRailComponentName,
+          PCNavigationRailProps,
+          PCNavigationRailEventEmitter,
+          PCNavigationRailStateFrameSize> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // Width used until native reports one: the Material 3 Expressive collapsed
+  // rail, and the iOS fallback's column of buttons
+  static constexpr float kFallbackWidthIOS = 80.0f;
+  static constexpr float kFallbackWidthAndroid = 96.0f;
+};
+
+} // namespace facebook::react