react-native-windows 0.0.0-canary.705 → 0.0.0-canary.706

package/Libraries/StyleSheet/StyleSheetTypes.js

@@ -11,7 +11,6 @@
 'use strict';
 
 import type AnimatedNode from '../Animated/nodes/AnimatedNode';
-import type {NativeColorValue} from './PlatformColorValueTypes';
 import type {
   ____DangerouslyImpreciseStyle_InternalOverrides,
   ____ImageStyle_InternalOverrides,
@@ -21,6 +20,7 @@ import type {
 } from './private/_StyleSheetTypesOverrides';
 import type {____TransformStyle_Internal} from './private/_TransformStyle';
 
+declare export opaque type NativeColorValue;
 export type ____ColorValue_Internal = null | string | number | NativeColorValue;
 export type ColorArrayValue = null | $ReadOnlyArray<____ColorValue_Internal>;
 export type PointValue = {

package/Libraries/StyleSheet/processColor.js

@@ -10,8 +10,7 @@
 
 'use strict';
 
-import type {NativeColorValue} from './PlatformColorValueTypes';
-import type {ColorValue} from './StyleSheet';
+import type {ColorValue, NativeColorValue} from './StyleSheet';
 
 const Platform = require('../Utilities/Platform');
 const normalizeColor = require('./normalizeColor');

package/Libraries/Utilities/Platform.android.js

@@ -8,16 +8,14 @@
  * @flow strict
  */
 
-import NativePlatformConstantsAndroid from './NativePlatformConstantsAndroid';
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
 
-export type PlatformSelectSpec<T> = {
-  android?: T,
-  native?: T,
-  default?: T,
-  ...
-};
+import NativePlatformConstantsAndroid from './NativePlatformConstantsAndroid';
 
-const Platform = {
+const Platform: PlatformType = {
   __constants: null,
   OS: 'android',
   // $FlowFixMe[unsafe-getters-setters]

package/Libraries/Utilities/Platform.flow.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+export type PlatformSelectSpec<T> = {
+  default?: T,
+  native?: T,
+  ios?: T,
+  android?: T,
+  ...
+};
+
+type IOSPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'ios'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): string,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    forceTouchAvailable: boolean,
+    interfaceIdiom: string,
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    osVersion: string,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    systemName: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isPad(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type AndroidPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'android'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    Version: number,
+    Release: string,
+    Serial: string,
+    Fingerprint: string,
+    Model: string,
+    ServerHost?: string,
+    uiMode: string,
+    Brand: string,
+    Manufacturer: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+export type Platform = IOSPlatform | AndroidPlatform;

package/Libraries/Utilities/Platform.flow.windows.js

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+export type PlatformSelectSpec<T> = {
+  default?: T,
+  native?: T,
+  ios?: T,
+  android?: T,
+  windows?: T,
+  ...
+};
+
+type IOSPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'ios'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): string,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    forceTouchAvailable: boolean,
+    interfaceIdiom: string,
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    osVersion: string,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    systemName: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isPad(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type AndroidPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'android'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?number,
+    |},
+    Version: number,
+    Release: string,
+    Serial: string,
+    Fingerprint: string,
+    Model: string,
+    ServerHost?: string,
+    uiMode: string,
+    Brand: string,
+    Manufacturer: string,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+type WindowsPlatform = {
+  __constants: null,
+  OS: $TEMPORARY$string<'windows'>,
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): number,
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?string,
+    |},
+    osVersion: number,
+  |},
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean,
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean,
+  select: <T>(spec: PlatformSelectSpec<T>) => T,
+};
+
+export type Platform = IOSPlatform | AndroidPlatform | WindowsPlatform;

package/Libraries/Utilities/Platform.ios.js

@@ -8,16 +8,14 @@
  * @flow strict
  */
 
-import NativePlatformConstantsIOS from './NativePlatformConstantsIOS';
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
 
-export type PlatformSelectSpec<T> = {
-  default?: T,
-  native?: T,
-  ios?: T,
-  ...
-};
+import NativePlatformConstantsIOS from './NativePlatformConstantsIOS';
 
-const Platform = {
+const Platform: PlatformType = {
   __constants: null,
   OS: 'ios',
   // $FlowFixMe[unsafe-getters-setters]

package/Libraries/Utilities/Platform.windows.js

@@ -6,16 +6,14 @@
  * @flow strict
  */
 
-import NativePlatformConstantsWin from './NativePlatformConstantsWin';
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
 
-export type PlatformSelectSpec<T> = {
-  windows?: T,
-  native?: T,
-  default?: T,
-  ...
-};
+import NativePlatformConstantsWin from './NativePlatformConstantsWin';
 
-const Platform = {
+const Platform: PlatformType = {
   __constants: null,
   OS: 'windows',
   // $FlowFixMe[unsafe-getters-setters]

package/Microsoft.ReactNative/Fabric/platform/react/components/view/windows/WindowsViewProps.cpp

@@ -7,6 +7,8 @@
 
 #include "WindowsViewProps.h"
 
+#include <react/renderer/components/view/conversions.h>
+#include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/core/propsConversions.h>
 #include <react/utils/CoreFeatures.h>
 
@@ -17,9 +19,64 @@ WindowsViewProps::WindowsViewProps(
     const WindowsViewProps &sourceProps,
     const RawProps &rawProps,
     bool shouldSetRawProps)
-    : windowsEvents(sourceProps.windowsEvents),
-      focusable(sourceProps.focusable),
-      enableFocusRing(sourceProps.enableFocusRing) {}
+    : BaseViewProps(context, sourceProps, rawProps, shouldSetRawProps),
+      windowsEvents(sourceProps.windowsEvents),
+      enableFocusRing(sourceProps.enableFocusRing),
+      elevation(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.elevation
+              : convertRawProp(context, rawProps, "elevation", sourceProps.elevation, {})),
+      focusable(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.focusable
+              : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})) {}
+// [Windows
+/*nativeBackground(
+    CoreFeatures::enablePropIteratorSetter
+        ? sourceProps.nativeBackground
+        : convertRawProp(
+              context,
+              rawProps,
+              "nativeBackgroundAndroid",
+              sourceProps.nativeBackground,
+              {})),
+nativeForeground(
+    CoreFeatures::enablePropIteratorSetter
+        ? sourceProps.nativeForeground
+        : convertRawProp(
+              context,
+              rawProps,
+              "nativeForegroundAndroid",
+              sourceProps.nativeForeground,
+              {})),
+hasTVPreferredFocus(
+    CoreFeatures::enablePropIteratorSetter
+        ? sourceProps.hasTVPreferredFocus
+        : convertRawProp(
+              context,
+              rawProps,
+              "hasTVPreferredFocus",
+              sourceProps.hasTVPreferredFocus,
+              {})),
+needsOffscreenAlphaCompositing(
+    CoreFeatures::enablePropIteratorSetter
+        ? sourceProps.needsOffscreenAlphaCompositing
+        : convertRawProp(
+              context,
+              rawProps,
+              "needsOffscreenAlphaCompositing",
+              sourceProps.needsOffscreenAlphaCompositing,
+              {})),
+renderToHardwareTextureAndroid(
+    CoreFeatures::enablePropIteratorSetter
+        ? sourceProps.renderToHardwareTextureAndroid
+        : convertRawProp(
+              context,
+              rawProps,
+              "renderToHardwareTextureAndroid",
+              sourceProps.renderToHardwareTextureAndroid,
+              {})) {}*/
+// Windows]
 
 #define WINDOWS_VIEW_EVENT_CASE(eventType)                    \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): {       \
@@ -38,6 +95,11 @@ void WindowsViewProps::setProp(
     RawPropsPropNameHash hash,
     const char *propName,
     RawValue const &value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
+  BaseViewProps::setProp(context, hash, propName, value);
+
   static auto defaults = WindowsViewProps{};
 
   switch (hash) {
@@ -47,9 +109,29 @@ void WindowsViewProps::setProp(
     WINDOWS_VIEW_EVENT_CASE(KeyDown);
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
     RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(elevation);
+    // [Windows
+    // RAW_SET_PROP_SWITCH_CASE(nativeBackground, "nativeBackgroundAndroid");
+    // RAW_SET_PROP_SWITCH_CASE(nativeForeground, "nativeForegroundAndroid");
+    // RAW_SET_PROP_SWITCH_CASE_BASIC(hasTVPreferredFocus);
+    // RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing);
+    // RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid);
+    // Windows]
   }
 }
 
+#ifdef ANDROID
+bool WindowsViewProps::getProbablyMoreHorizontalThanVertical_DEPRECATED() const {
+  return yogaStyle.flexDirection() == YGFlexDirectionRow;
+}
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList WindowsViewProps::getDebugProps() const {
+  return BaseViewProps::getDebugProps();
+}
+#endif
+
 /*static*/ bool WindowsViewProps::requiresFormsStackingContext(const WindowsViewProps &props) noexcept {
   return props.windowsEvents.bits.any();
 }

package/Microsoft.ReactNative/Fabric/platform/react/components/view/windows/WindowsViewProps.h

@@ -4,11 +4,11 @@
 #pragma once
 
 #include <react/components/view/windows/primitives.h>
-#include <react/renderer/core/Props.h>
+#include <react/renderer/components/view/BaseViewProps.h>
 #include <react/renderer/core/PropsParserContext.h>
 
 namespace facebook::react {
-class WindowsViewProps {
+class WindowsViewProps : public BaseViewProps {
  public:
   WindowsViewProps() = default;
   WindowsViewProps(
@@ -20,15 +20,40 @@ class WindowsViewProps {
   void
   setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, RawValue const &value);
 
+#ifdef ANDROID
+  void propsDiffMapBuffer(Props const *oldProps, MapBufferBuilder &builder) const override;
+#endif
+
   static bool requiresFormsStackingContext(const WindowsViewProps &props) noexcept;
   static bool requiresFormsView(const WindowsViewProps &props) noexcept;
 
+  Float elevation{};
   WindowsViewEvents windowsEvents{};
   bool enableFocusRing{true};
   bool focusable{false};
+
   // std::optional<std::string> overflowAnchor{};
   // std::optional<std::string> tooltip{};
   // std::vector<HandledKeyEvent> keyDownEvents{};
   // std::vector<HandledKeyEvent> keyUpEvents{};
+
+#ifdef ANDROID
+
+  std::optional<NativeDrawable> nativeBackground{};
+  std::optional<NativeDrawable> nativeForeground{};
+
+  bool hasTVPreferredFocus{false};
+  bool needsOffscreenAlphaCompositing{false};
+  bool renderToHardwareTextureAndroid{false};
+
+#endif
+
+#ifdef ANDROID
+  bool getProbablyMoreHorizontalThanVertical_DEPRECATED() const override;
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+#endif
 };
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformTouch.h

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/view/BaseTouch.h>
+
+namespace facebook::react {
+using HostPlatformTouch = BaseTouch;
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.h

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/view/BaseViewEventEmitter.h>
+
+namespace facebook::react {
+using HostPlatformViewEventEmitter = BaseViewEventEmitter;
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -0,0 +1,32 @@
+/*
+ * 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/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+
+namespace facebook::react::HostPlatformViewTraitsInitializer {
+
+inline bool formsStackingContext(ViewProps const &viewProps) {
+  return viewProps.elevation != 0;
+}
+
+inline bool formsView(ViewProps const &viewProps) {
+#ifdef ANDROID
+  return viewProps.nativeBackground.has_value() || viewProps.nativeForeground.has_value() || viewProps.focusable ||
+      viewProps.hasTVPreferredFocus || viewProps.needsOffscreenAlphaCompositing ||
+      viewProps.renderToHardwareTextureAndroid;
+#endif
+  return viewProps.focusable;
+}
+
+inline ShadowNodeTraits::Trait extraTraits() {
+  return ShadowNodeTraits::Trait::AndroidMapBufferPropsSupported;
+}
+
+} // namespace facebook::react::HostPlatformViewTraitsInitializer

package/Microsoft.ReactNative/Fabric/platform/react/renderer/core/graphicsConversions.h

@@ -54,8 +54,8 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
     }
   }
   // Windows]
-
   result = colorFromComponents(colorComponents);
+  return;
 }
 
 #ifdef ANDROID

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/Color.h

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #include <functional>
 #include <limits>
 
@@ -35,7 +34,9 @@ struct Color {
  * On Android, a color can be represented as 32 bits integer, so there is no
  * need to instantiate complex color objects and then pass them as shared
  * pointers. Hence instead of using shared_ptr, we use a simple wrapper class
- * which provides a pointer-like interface.
+ * which provides a pointer-like interface. On other platforms, colors may be
+ * represented by more complex objects that cannot be represented as 32-bits
+ * integers, so we hide the implementation detail in HostPlatformColor.h.
  */
 class SharedColor {
   friend std::hash<SharedColor>;