react-native-windows 0.0.0-canary.718 → 0.0.0-canary.720

package/.flowconfig

@@ -28,6 +28,7 @@
 <PROJECT_ROOT>/Libraries/Components/View/View.js
 <PROJECT_ROOT>/Libraries/DeprecatedPropTypes/DeprecatedViewAccessibility.js
 <PROJECT_ROOT>/Libraries/Image/Image.js
+<PROJECT_ROOT>/Libraries/Image/resolveAssetSource.js
 <PROJECT_ROOT>/Libraries/Network/RCTNetworking.js
 <PROJECT_ROOT>/Libraries/NewAppScreen/components/DebugInstructions.js
 <PROJECT_ROOT>/Libraries/NewAppScreen/components/ReloadInstructions.js
@@ -141,4 +142,4 @@ untyped-import
 untyped-type-import
 
 [version]
-^0.217.0
+^0.217.2

package/Libraries/Components/TextInput/TextInput.d.ts

@@ -738,6 +738,11 @@ export interface TextInputProps
     | ((e: NativeSyntheticEvent<TextInputEndEditingEventData>) => void)
     | undefined;
 
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ((e: NativeSyntheticEvent<NativeTouchEvent>) => void) | undefined;
+
   /**
    * Callback that is called when a touch is engaged.
    */

package/Libraries/Components/TextInput/TextInput.flow.js

@@ -766,6 +766,11 @@ export type Props = $ReadOnly<{|
    */
   unstable_onKeyPressSync?: ?(e: KeyPressEvent) => mixed,
 
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ?(event: PressEvent) => mixed,
+
   /**
    * Called when a touch is engaged.
    */

package/Libraries/Components/TextInput/TextInput.js

@@ -808,6 +808,11 @@ export type Props = $ReadOnly<{|
    */
   unstable_onKeyPressSync?: ?(e: KeyPressEvent) => mixed,
 
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ?(event: PressEvent) => mixed,
+
   /**
    * Called when a touch is engaged.
    */
@@ -1378,27 +1383,37 @@ function InternalTextInput(props: Props): React.Node {
   const accessible = props.accessible !== false;
   const focusable = props.focusable !== false;
 
+  const {
+    editable,
+    hitSlop,
+    onPress,
+    onPressIn,
+    onPressOut,
+    rejectResponderTermination,
+  } = props;
+
   const config = React.useMemo(
     () => ({
-      hitSlop: props.hitSlop,
+      hitSlop,
       onPress: (event: PressEvent) => {
-        if (props.editable !== false) {
+        onPress?.(event);
+        if (editable !== false) {
           if (inputRef.current != null) {
             inputRef.current.focus();
           }
         }
       },
-      onPressIn: props.onPressIn,
-      onPressOut: props.onPressOut,
-      cancelable:
-        Platform.OS === 'ios' ? !props.rejectResponderTermination : null,
+      onPressIn: onPressIn,
+      onPressOut: onPressOut,
+      cancelable: Platform.OS === 'ios' ? !rejectResponderTermination : null,
     }),
     [
-      props.editable,
-      props.hitSlop,
-      props.onPressIn,
-      props.onPressOut,
-      props.rejectResponderTermination,
+      editable,
+      hitSlop,
+      onPress,
+      onPressIn,
+      onPressOut,
+      rejectResponderTermination,
     ],
   );
 

package/Libraries/Components/TextInput/TextInput.windows.js

@@ -885,6 +885,11 @@ export type Props = $ReadOnly<{|
    */
   unstable_onKeyPressSync?: ?(e: KeyPressEvent) => mixed,
 
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ?(event: PressEvent) => mixed,
+
   /**
    * Called when a touch is engaged.
    */
@@ -1467,27 +1472,37 @@ function InternalTextInput(props: Props): React.Node {
 
   const focusable = props.focusable !== false;
 
+  const {
+    editable,
+    hitSlop,
+    onPress,
+    onPressIn,
+    onPressOut,
+    rejectResponderTermination,
+  } = props;
+
   const config = React.useMemo(
     () => ({
-      hitSlop: props.hitSlop,
+      hitSlop,
       onPress: (event: PressEvent) => {
-        if (props.editable !== false) {
+        onPress?.(event);
+        if (editable !== false) {
           if (inputRef.current != null) {
             inputRef.current.focus();
           }
         }
       },
-      onPressIn: props.onPressIn,
-      onPressOut: props.onPressOut,
-      cancelable:
-        Platform.OS === 'ios' ? !props.rejectResponderTermination : null,
+      onPressIn: onPressIn,
+      onPressOut: onPressOut,
+      cancelable: Platform.OS === 'ios' ? !rejectResponderTermination : null,
     }),
     [
-      props.editable,
-      props.hitSlop,
-      props.onPressIn,
-      props.onPressOut,
-      props.rejectResponderTermination,
+      editable,
+      hitSlop,
+      onPress,
+      onPressIn,
+      onPressOut,
+      rejectResponderTermination,
     ],
   );
 

package/Libraries/Core/ReactNativeVersion.js

@@ -13,5 +13,5 @@ exports.version = {
   major: 0,
   minor: 73,
   patch: 0,
-  prerelease: 'nightly-20230925-2de964cfd',
+  prerelease: 'nightly-20231002-0371014a3',
 };

package/Libraries/Image/resolveAssetSource.windows.js

@@ -0,0 +1,115 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow
+ */
+
+// Resolves an asset into a `source` for `Image`.
+
+'use strict';
+
+import type {ResolvedAssetSource} from './AssetSourceResolver';
+
+const AssetSourceResolver = require('./AssetSourceResolver');
+const Platform = require('../Utilities/Platform');
+const {pickScale} = require('./AssetUtils');
+const AssetRegistry = require('@react-native/assets-registry/registry');
+
+let _customSourceTransformer, _serverURL, _scriptURL;
+
+let _sourceCodeScriptURL: ?string;
+function getSourceCodeScriptURL(): ?string {
+  if (_sourceCodeScriptURL) {
+    return _sourceCodeScriptURL;
+  }
+
+  let sourceCode =
+    global.nativeExtensions && global.nativeExtensions.SourceCode;
+  if (!sourceCode) {
+    sourceCode = require('../NativeModules/specs/NativeSourceCode').default;
+  }
+  _sourceCodeScriptURL = sourceCode.getConstants().scriptURL;
+  return _sourceCodeScriptURL;
+}
+
+function getDevServerURL(): ?string {
+  if (_serverURL === undefined) {
+    const sourceCodeScriptURL = getSourceCodeScriptURL();
+    const match =
+      sourceCodeScriptURL && sourceCodeScriptURL.match(/^https?:\/\/.*?\//);
+    if (match) {
+      // jsBundle was loaded from network
+      _serverURL = match[0];
+    } else {
+      // jsBundle was loaded from file
+      _serverURL = null;
+    }
+  }
+  return _serverURL;
+}
+
+function _coerceLocalScriptURL(scriptURL: ?string): ?string {
+  if (Platform.OS === 'windows') {
+    return scriptURL;
+  }
+
+  if (scriptURL) {
+    if (scriptURL.startsWith('assets://')) {
+      // android: running from within assets, no offline path to use
+      return null;
+    }
+    scriptURL = scriptURL.substring(0, scriptURL.lastIndexOf('/') + 1);
+    if (!scriptURL.includes('://')) {
+      // Add file protocol in case we have an absolute file path and not a URL.
+      // This shouldn't really be necessary. scriptURL should be a URL.
+      scriptURL = 'file://' + scriptURL;
+    }
+  }
+  return scriptURL;
+}
+
+function getScriptURL(): ?string {
+  if (_scriptURL === undefined) {
+    _scriptURL = _coerceLocalScriptURL(getSourceCodeScriptURL());
+  }
+  return _scriptURL;
+}
+
+function setCustomSourceTransformer(
+  transformer: (resolver: AssetSourceResolver) => ResolvedAssetSource,
+): void {
+  _customSourceTransformer = transformer;
+}
+
+/**
+ * `source` is either a number (opaque type returned by require('./foo.png'))
+ * or an `ImageSource` like { uri: '<http location || file path>' }
+ */
+function resolveAssetSource(source: any): ?ResolvedAssetSource {
+  if (typeof source === 'object') {
+    return source;
+  }
+
+  const asset = AssetRegistry.getAssetByID(source);
+  if (!asset) {
+    return null;
+  }
+
+  const resolver = new AssetSourceResolver(
+    getDevServerURL(),
+    getScriptURL(),
+    asset,
+  );
+  if (_customSourceTransformer) {
+    return _customSourceTransformer(resolver);
+  }
+  return resolver.defaultAsset();
+}
+
+resolveAssetSource.pickScale = pickScale;
+resolveAssetSource.setCustomSourceTransformer = setCustomSourceTransformer;
+module.exports = resolveAssetSource;

package/Libraries/NativeComponent/NativeComponentRegistry.js

@@ -55,14 +55,20 @@ export function get<Config>(
 ): HostComponent<Config> {
   ReactNativeViewConfigRegistry.register(name, () => {
     const {native, strict, verify} = getRuntimeConfig?.(name) ?? {
-      native: true,
+      native: !global.RN$Bridgeless,
       strict: false,
       verify: false,
     };
 
-    const viewConfig = native
-      ? getNativeComponentAttributes(name)
-      : createViewConfig(viewConfigProvider());
+    let viewConfig;
+    if (native) {
+      viewConfig = getNativeComponentAttributes(name);
+    } else {
+      viewConfig = createViewConfig(viewConfigProvider());
+      if (viewConfig == null) {
+        viewConfig = getNativeComponentAttributes(name);
+      }
+    }
 
     if (verify) {
       const nativeViewConfig = native

package/Libraries/Network/FormData.js

@@ -82,7 +82,9 @@ class FormData {
       // content type (cf. web Blob interface.)
       if (typeof value === 'object' && !Array.isArray(value) && value) {
         if (typeof value.name === 'string') {
-          headers['content-disposition'] += '; filename="' + value.name + '"';
+          headers['content-disposition'] += `; filename="${
+            value.name
+          }"; filename*=utf-8''${encodeURI(value.name)}`;
         }
         if (typeof value.type === 'string') {
           headers['content-type'] = value.type;

package/Libraries/ReactNative/BridgelessUIManager.js

@@ -13,7 +13,6 @@
 import type {RootTag} from '../Types/RootTagTypes';
 
 import {unstable_hasComponent} from '../NativeComponent/NativeComponentRegistryUnstable';
-import ReactNativeFeatureFlags from './ReactNativeFeatureFlags';
 
 let cachedConstants = null;
 
@@ -22,6 +21,10 @@ const errorMessageForMethod = (methodName: string): string =>
   methodName +
   "' is not available in the new React Native architecture.";
 
+function nativeViewConfigsInBridgelessModeEnabled(): boolean {
+  return global.RN$LegacyInterop_UIManager_getConstants !== undefined;
+}
+
 function getCachedConstants(): Object {
   if (!cachedConstants) {
     cachedConstants = global.RN$LegacyInterop_UIManager_getConstants();
@@ -29,9 +32,9 @@ function getCachedConstants(): Object {
   return cachedConstants;
 }
 
-module.exports = {
+const UIManagerJS: {[string]: $FlowFixMe} = {
   getViewManagerConfig: (viewManagerName: string): mixed => {
-    if (ReactNativeFeatureFlags.enableNativeViewConfigsInBridgelessMode()) {
+    if (nativeViewConfigsInBridgelessModeEnabled()) {
       return getCachedConstants()[viewManagerName];
     } else {
       console.error(
@@ -46,7 +49,7 @@ module.exports = {
     return unstable_hasComponent(viewManagerName);
   },
   getConstants: (): Object => {
-    if (ReactNativeFeatureFlags.enableNativeViewConfigsInBridgelessMode()) {
+    if (nativeViewConfigsInBridgelessModeEnabled()) {
       return getCachedConstants();
     } else {
       console.error(errorMessageForMethod('getConstants'));
@@ -178,3 +181,11 @@ module.exports = {
   dismissPopupMenu: (): void =>
     console.error(errorMessageForMethod('dismissPopupMenu')),
 };
+
+if (nativeViewConfigsInBridgelessModeEnabled()) {
+  Object.keys(getCachedConstants()).forEach(viewConfigName => {
+    UIManagerJS[viewConfigName] = getCachedConstants()[viewConfigName];
+  });
+}
+
+module.exports = UIManagerJS;

package/Libraries/ReactNative/ReactNativeFeatureFlags.js

@@ -54,10 +54,6 @@ export type FeatureFlags = {|
    * Enables use of setNativeProps in JS driven animations.
    */
   shouldUseSetNativePropsInFabric: () => boolean,
-  /**
-   * Enables native view configs in brdgeless mode.
-   */
-  enableNativeViewConfigsInBridgelessMode: () => boolean,
   /**
    * Enables a hotfix for forcing materialization of views with elevation set.
    */
@@ -74,7 +70,6 @@ const ReactNativeFeatureFlags: FeatureFlags = {
   enableAccessToHostTreeInFabric: () => false,
   shouldUseAnimatedObjectForTransform: () => false,
   shouldUseSetNativePropsInFabric: () => false,
-  enableNativeViewConfigsInBridgelessMode: () => false,
   shouldForceUnflattenForElevation: () => false,
 };
 

package/Libraries/Utilities/PixelRatio.d.ts

@@ -32,11 +32,11 @@ export interface PixelRatioStatic {
           used to calculate the absolute font size, so any elements that
           heavily depend on that should use this to do calculations.
 
-          If a font scale is not set, this returns the device pixel ratio.
+          * on Android value reflects the user preference set in Settings > Display > Font size
+          * on iOS value reflects the user preference set in Settings > Display & Brightness > Text Size,
+            value can also be updated in Settings > Accessibility > Display & Text Size > Larger Text
 
-          Currently this is only implemented on Android and reflects the user
-          preference set in Settings > Display > Font size,
-          on iOS it will always return the default pixel ratio.
+          If a font scale is not set, this returns the device pixel ratio.
           */
   getFontScale(): number;
 

package/Microsoft.ReactNative/Utils/ImageUtils.h

@@ -13,7 +13,6 @@ enum class ImageSourceFormat { Bitmap = 0, Svg = 1 };
 struct ReactImageSource {
   std::string uri;
   std::string method;
-  std::string bundleRootPath;
   std::vector<std::pair<std::string, std::string>> headers;
   double width = 0;
   double height = 0;

package/Microsoft.ReactNative/Views/Image/ImageViewManager.cpp

@@ -185,11 +185,6 @@ void ImageViewManager::EmitImageEvent(
 
 void ImageViewManager::setSource(winrt::Grid grid, const winrt::Microsoft::ReactNative::JSValue &data) {
   auto sources{json_type_traits<std::vector<ReactImageSource>>::parseJson(data)};
-  sources[0].bundleRootPath = GetReactContext().SettingsSnapshot().BundleRootPath();
-
-  if (sources[0].packagerAsset && sources[0].uri.find("file://") == 0) {
-    sources[0].uri.replace(0, 7, sources[0].bundleRootPath);
-  }
 
   auto reactImage{grid.as<ReactImage>()};
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.718</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.720</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>true</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>a0946739c12f78f5151c1168ec73b57f0af9cbe9</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>eced4875349d205e61fbe17f9390dfae60b0cdee</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -533,9 +533,11 @@ void YogaLayoutableShadowNode::setSize(Size size) const {
 
   auto style = yogaNode_.getStyle();
   style.setDimension(
-      YGDimensionWidth, yoga::CompactValue::ofMaybe<YGUnitPoint>(size.width));
+      yoga::Dimension::Width,
+      yoga::CompactValue::ofMaybe<YGUnitPoint>(size.width));
   style.setDimension(
-      YGDimensionHeight, yoga::CompactValue::ofMaybe<YGUnitPoint>(size.height));
+      yoga::Dimension::Height,
+      yoga::CompactValue::ofMaybe<YGUnitPoint>(size.height));
   yogaNode_.setStyle(style);
   yogaNode_.setDirty(true);
 }
@@ -631,19 +633,19 @@ void YogaLayoutableShadowNode::layoutTree(
   auto ownerHeight = yogaFloatFromFloat(maximumSize.height);
 
   yogaStyle.setMaxDimension(
-      YGDimensionWidth,
+      yoga::Dimension::Width,
       yoga::CompactValue::ofMaybe<YGUnitPoint>(maximumSize.width));
 
   yogaStyle.setMaxDimension(
-      YGDimensionHeight,
+      yoga::Dimension::Height,
       yoga::CompactValue::ofMaybe<YGUnitPoint>(maximumSize.height));
 
   yogaStyle.setMinDimension(
-      YGDimensionWidth,
+      yoga::Dimension::Width,
       yoga::CompactValue::ofMaybe<YGUnitPoint>(minimumSize.width));
 
   yogaStyle.setMinDimension(
-      YGDimensionHeight,
+      yoga::Dimension::Height,
       yoga::CompactValue::ofMaybe<YGUnitPoint>(minimumSize.height));
 
   auto direction =

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/YogaStylableProps.cpp

@@ -191,9 +191,9 @@ static inline T const getFieldValue(
 
 #define REBUILD_FIELD_YG_DIMENSION(field, setter, widthStr, heightStr) \
   REBUILD_YG_FIELD_SWITCH_CASE_INDEXED_SETTER(                         \
-      field, setter, YGDimensionWidth, widthStr);                      \
+      field, setter, yoga::Dimension::Width, widthStr);                      \
   REBUILD_YG_FIELD_SWITCH_CASE_INDEXED_SETTER(                         \
-      field, setter, YGDimensionHeight, heightStr);
+      field, setter, yoga::Dimension::Height, heightStr);
 
 #define REBUILD_FIELD_YG_GUTTER(field, rowGapStr, columnGapStr, gapStr)      \
   REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGGutterRow, rowGapStr);       \
@@ -349,28 +349,28 @@ SharedDebugStringConvertibleList YogaStylableProps::getDebugProps() const {
           "border", yogaStyle.border(), defaultYogaStyle.border()),
       debugStringConvertibleItem(
           "width",
-          yogaStyle.dimension(YGDimensionWidth),
-          defaultYogaStyle.dimension(YGDimensionWidth)),
+          yogaStyle.dimension(yoga::Dimension::Width),
+          defaultYogaStyle.dimension(yoga::Dimension::Width)),
       debugStringConvertibleItem(
           "height",
-          yogaStyle.dimension(YGDimensionHeight),
-          defaultYogaStyle.dimension(YGDimensionHeight)),
+          yogaStyle.dimension(yoga::Dimension::Height),
+          defaultYogaStyle.dimension(yoga::Dimension::Height)),
       debugStringConvertibleItem(
           "minWidth",
-          yogaStyle.minDimension(YGDimensionWidth),
-          defaultYogaStyle.minDimension(YGDimensionWidth)),
+          yogaStyle.minDimension(yoga::Dimension::Width),
+          defaultYogaStyle.minDimension(yoga::Dimension::Width)),
       debugStringConvertibleItem(
           "minHeight",
-          yogaStyle.minDimension(YGDimensionHeight),
-          defaultYogaStyle.minDimension(YGDimensionHeight)),
+          yogaStyle.minDimension(yoga::Dimension::Height),
+          defaultYogaStyle.minDimension(yoga::Dimension::Height)),
       debugStringConvertibleItem(
           "maxWidth",
-          yogaStyle.maxDimension(YGDimensionWidth),
-          defaultYogaStyle.maxDimension(YGDimensionWidth)),
+          yogaStyle.maxDimension(yoga::Dimension::Width),
+          defaultYogaStyle.maxDimension(yoga::Dimension::Width)),
       debugStringConvertibleItem(
           "maxHeight",
-          yogaStyle.maxDimension(YGDimensionHeight),
-          defaultYogaStyle.maxDimension(YGDimensionHeight)),
+          yogaStyle.maxDimension(yoga::Dimension::Height),
+          defaultYogaStyle.maxDimension(yoga::Dimension::Height)),
       debugStringConvertibleItem(
           "aspectRatio",
           yogaStyle.aspectRatio(),

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/enums/YogaEnums.h

@@ -0,0 +1,27 @@
+/*
+ * 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::yoga {
+
+template <typename EnumT>
+constexpr inline int32_t ordinalCount();
+
+template <typename EnumT>
+constexpr inline int32_t bitCount();
+
+// Polyfill of C++ 23 to_underlying()
+// https://en.cppreference.com/w/cpp/utility/to_underlying
+template <typename T>
+constexpr auto to_underlying(T e) noexcept {
+  return static_cast<std::underlying_type_t<decltype(e)>>(e);
+}
+
+} // namespace facebook::yoga

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/LayoutResults.h

@@ -10,6 +10,7 @@
 #include <array>
 
 #include <yoga/bits/NumericBitfield.h>
+#include <yoga/enums/Dimension.h>
 #include <yoga/enums/Direction.h>
 #include <yoga/node/CachedMeasurement.h>
 #include <yoga/numeric/FloatOptional.h>
@@ -63,20 +64,20 @@ struct LayoutResults {
     hadOverflow_ = hadOverflow;
   }
 
-  float dimension(YGDimension axis) const {
-    return dimensions_[axis];
+  float dimension(Dimension axis) const {
+    return dimensions_[yoga::to_underlying(axis)];
   }
 
-  void setDimension(YGDimension axis, float dimension) {
-    dimensions_[axis] = dimension;
+  void setDimension(Dimension axis, float dimension) {
+    dimensions_[yoga::to_underlying(axis)] = dimension;
   }
 
-  float measuredDimension(YGDimension axis) const {
-    return measuredDimensions_[axis];
+  float measuredDimension(Dimension axis) const {
+    return measuredDimensions_[yoga::to_underlying(axis)];
   }
 
-  void setMeasuredDimension(YGDimension axis, float dimension) {
-    measuredDimensions_[axis] = dimension;
+  void setMeasuredDimension(Dimension axis, float dimension) {
+    measuredDimensions_[yoga::to_underlying(axis)] = dimension;
   }
 
   bool operator==(LayoutResults layout) const;

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/Node.cpp

@@ -202,13 +202,13 @@ FloatOptional Node::getMarginForAxis(
   return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
 }
 
-FloatOptional Node::getGapForAxis(
-    const FlexDirection axis,
-    const float widthSize) const {
+float Node::getGapForAxis(const FlexDirection axis, const float widthSize)
+    const {
   auto gap = isRow(axis)
-      ? computeColumnGap(style_.gap(), CompactValue::ofZero())
-      : computeRowGap(style_.gap(), CompactValue::ofZero());
-  return yoga::resolveValue(gap, widthSize);
+      ? computeColumnGap(style_.gap(), CompactValue::ofUndefined())
+      : computeRowGap(style_.gap(), CompactValue::ofUndefined());
+  auto resolvedGap = yoga::resolveValue(gap, widthSize);
+  return maxOrDefined(resolvedGap.unwrap(), 0);
 }
 
 YGSize Node::measure(
@@ -339,7 +339,7 @@ void Node::setLayoutComputedFlexBasisGeneration(
 
 void Node::setLayoutMeasuredDimension(
     float measuredDimension,
-    YGDimension dimension) {
+    Dimension dimension) {
   layout_.setMeasuredDimension(dimension, measuredDimension);
 }
 
@@ -347,7 +347,7 @@ void Node::setLayoutHadOverflow(bool hadOverflow) {
   layout_.setHadOverflow(hadOverflow);
 }
 
-void Node::setLayoutDimension(float dimensionValue, YGDimension dimension) {
+void Node::setLayoutDimension(float dimensionValue, Dimension dimension) {
   layout_.setDimension(dimension, dimensionValue);
 }
 
@@ -433,14 +433,13 @@ YGValue Node::resolveFlexBasisPtr() const {
 }
 
 void Node::resolveDimension() {
-  using namespace yoga;
   const Style& style = getStyle();
-  for (auto dim : {YGDimensionWidth, YGDimensionHeight}) {
+  for (auto dim : {Dimension::Width, Dimension::Height}) {
     if (!style.maxDimension(dim).isUndefined() &&
         yoga::inexactEquals(style.maxDimension(dim), style.minDimension(dim))) {
-      resolvedDimensions_[dim] = style.maxDimension(dim);
+      resolvedDimensions_[yoga::to_underlying(dim)] = style.maxDimension(dim);
     } else {
-      resolvedDimensions_[dim] = style.dimension(dim);
+      resolvedDimensions_[yoga::to_underlying(dim)] = style.dimension(dim);
     }
   }
 }

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/Node.h

@@ -14,6 +14,7 @@
 #include <yoga/Yoga.h>
 
 #include <yoga/config/Config.h>
+#include <yoga/enums/Dimension.h>
 #include <yoga/enums/Direction.h>
 #include <yoga/enums/Errata.h>
 #include <yoga/enums/MeasureMode.h>
@@ -175,7 +176,7 @@ class YG_EXPORT Node : public ::YGNode {
     return resolvedDimensions_;
   }
 
-  YGValue getResolvedDimension(YGDimension dimension) const {
+  YGValue getResolvedDimension(Dimension dimension) const {
     return resolvedDimensions_[static_cast<size_t>(dimension)];
   }
 
@@ -230,8 +231,7 @@ class YG_EXPORT Node : public ::YGNode {
   FloatOptional getMarginForAxis(
       const FlexDirection axis,
       const float widthSize) const;
-  FloatOptional getGapForAxis(const FlexDirection axis, const float widthSize)
-      const;
+  float getGapForAxis(const FlexDirection axis, const float widthSize) const;
   // Setters
 
   void setContext(void* context) {
@@ -293,11 +293,9 @@ class YG_EXPORT Node : public ::YGNode {
   void setLayoutComputedFlexBasis(const FloatOptional computedFlexBasis);
   void setLayoutComputedFlexBasisGeneration(
       uint32_t computedFlexBasisGeneration);
-  void setLayoutMeasuredDimension(
-      float measuredDimension,
-      YGDimension dimension);
+  void setLayoutMeasuredDimension(float measuredDimension, Dimension dimension);
   void setLayoutHadOverflow(bool hadOverflow);
-  void setLayoutDimension(float dimensionValue, YGDimension dimension);
+  void setLayoutDimension(float dimensionValue, Dimension dimension);
   void setLayoutDirection(Direction direction);
   void setLayoutMargin(float margin, YGEdge edge);
   void setLayoutBorder(float border, YGEdge edge);

package/ReactCommon/Yoga.cpp

@@ -661,97 +661,97 @@ void YGNodeStyleSetAspectRatio(const YGNodeRef node, const float aspectRatio) {
 void YGNodeStyleSetWidth(YGNodeRef node, float points) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 void YGNodeStyleSetWidthAuto(YGNodeRef node) {
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionWidth, CompactValue::ofAuto());
+      node, Dimension::Width, CompactValue::ofAuto());
 }
 YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().dimension(YGDimensionWidth);
+  return resolveRef(node)->getStyle().dimension(Dimension::Width);
 }
 
 void YGNodeStyleSetHeight(YGNodeRef node, float points) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(points);
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(percent);
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 void YGNodeStyleSetHeightAuto(YGNodeRef node) {
   updateIndexedStyleProp<&Style::dimension, &Style::setDimension>(
-      node, YGDimensionHeight, CompactValue::ofAuto());
+      node, Dimension::Height, CompactValue::ofAuto());
 }
 YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().dimension(YGDimensionHeight);
+  return resolveRef(node)->getStyle().dimension(Dimension::Height);
 }
 
 void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(minWidth);
   updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(minWidth);
   updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().minDimension(YGDimensionWidth);
+  return resolveRef(node)->getStyle().minDimension(Dimension::Width);
 }
 
 void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(minHeight);
   updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 void YGNodeStyleSetMinHeightPercent(
     const YGNodeRef node,
     const float minHeight) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(minHeight);
   updateIndexedStyleProp<&Style::minDimension, &Style::setMinDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().minDimension(YGDimensionHeight);
+  return resolveRef(node)->getStyle().minDimension(Dimension::Height);
 }
 
 void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(maxWidth);
   updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(maxWidth);
   updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
-      node, YGDimensionWidth, value);
+      node, Dimension::Width, value);
 }
 YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().maxDimension(YGDimensionWidth);
+  return resolveRef(node)->getStyle().maxDimension(Dimension::Width);
 }
 
 void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
   auto value = CompactValue::ofMaybe<YGUnitPoint>(maxHeight);
   updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 void YGNodeStyleSetMaxHeightPercent(
     const YGNodeRef node,
     const float maxHeight) {
   auto value = CompactValue::ofMaybe<YGUnitPercent>(maxHeight);
   updateIndexedStyleProp<&Style::maxDimension, &Style::setMaxDimension>(
-      node, YGDimensionHeight, value);
+      node, Dimension::Height, value);
 }
 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
-  return resolveRef(node)->getStyle().maxDimension(YGDimensionHeight);
+  return resolveRef(node)->getStyle().maxDimension(Dimension::Height);
 }
 
 namespace {
@@ -804,11 +804,11 @@ float YGNodeLayoutGetBottom(const YGNodeConstRef node) {
 }
 
 float YGNodeLayoutGetWidth(const YGNodeConstRef node) {
-  return resolveRef(node)->getLayout().dimension(YGDimensionWidth);
+  return resolveRef(node)->getLayout().dimension(Dimension::Width);
 }
 
 float YGNodeLayoutGetHeight(const YGNodeConstRef node) {
-  return resolveRef(node)->getLayout().dimension(YGDimensionHeight);
+  return resolveRef(node)->getLayout().dimension(Dimension::Height);
 }
 
 YGDirection YGNodeLayoutGetDirection(const YGNodeConstRef node) {

package/Shared/OInstance.cpp

@@ -597,7 +597,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
             m_devSettings->useFastRefresh,
             m_devSettings->inlineSourceMap,
             hermesBytecodeVersion)
-      : std::string();
+      : m_devSettings->bundleRootPath;
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       facebook::react::SourceCodeModule::Name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.718",
+  "version": "0.0.0-canary.720",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,13 +28,13 @@
     "@react-native-community/cli-platform-ios": "12.0.0-alpha.15",
     "@react-native-windows/cli": "0.0.0-canary.192",
     "@react-native/assets": "1.0.0",
-    "@react-native/assets-registry": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/codegen": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/community-cli-plugin": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/gradle-plugin": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/js-polyfills": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/normalize-colors": "0.73.0-nightly-20230925-2de964cfd",
-    "@react-native/virtualized-lists": "0.73.0-nightly-20230925-2de964cfd",
+    "@react-native/assets-registry": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/codegen": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/community-cli-plugin": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/gradle-plugin": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/js-polyfills": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/normalize-colors": "0.73.0-nightly-20231002-0371014a3",
+    "@react-native/virtualized-lists": "0.73.0-nightly-20231002-0371014a3",
     "abort-controller": "^3.0.0",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",
@@ -81,14 +81,14 @@
     "just-scripts": "^1.3.3",
     "prettier": "^2.4.1",
     "react": "18.2.0",
-    "react-native": "0.73.0-nightly-20230925-2de964cfd",
+    "react-native": "0.73.0-nightly-20231002-0371014a3",
     "react-native-platform-override": "^1.9.16",
     "react-refresh": "^0.4.0",
     "typescript": "^4.9.5"
   },
   "peerDependencies": {
     "react": "18.2.0",
-    "react-native": "0.73.0-nightly-20230925-2de964cfd"
+    "react-native": "0.73.0-nightly-20231002-0371014a3"
   },
   "beachball": {
     "defaultNpmTag": "canary",

package/Libraries/Components/ScrollView/ScrollViewViewConfig.js

@@ -1,85 +0,0 @@
-/**
- * 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-local
- * @format
- */
-
-'use strict';
-
-import type {PartialViewConfig} from '../../Renderer/shims/ReactNativeTypes';
-
-const ScrollViewViewConfig = {
-  uiViewClassName: 'RCTScrollView',
-  bubblingEventTypes: {},
-  directEventTypes: {
-    topScrollToTop: {
-      registrationName: 'onScrollToTop',
-    },
-  },
-  validAttributes: {
-    alwaysBounceHorizontal: true,
-    alwaysBounceVertical: true,
-    automaticallyAdjustContentInsets: true,
-    automaticallyAdjustKeyboardInsets: true,
-    automaticallyAdjustsScrollIndicatorInsets: true,
-    bounces: true,
-    bouncesZoom: true,
-    canCancelContentTouches: true,
-    centerContent: true,
-    contentInset: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    contentOffset: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    contentInsetAdjustmentBehavior: true,
-    decelerationRate: true,
-    directionalLockEnabled: true,
-    disableIntervalMomentum: true,
-    endFillColor: {
-      process: require('../../StyleSheet/processColor').default,
-    },
-    fadingEdgeLength: true,
-    indicatorStyle: true,
-    inverted: true,
-    isInvertedVirtualizedList: true,
-    keyboardDismissMode: true,
-    maintainVisibleContentPosition: true,
-    maximumZoomScale: true,
-    minimumZoomScale: true,
-    nestedScrollEnabled: true,
-    onMomentumScrollBegin: true,
-    onMomentumScrollEnd: true,
-    onScroll: true,
-    onScrollBeginDrag: true,
-    onScrollEndDrag: true,
-    onScrollToTop: true,
-    overScrollMode: true,
-    pagingEnabled: true,
-    persistentScrollbar: true,
-    pinchGestureEnabled: true,
-    scrollEnabled: true,
-    scrollEventThrottle: true,
-    scrollIndicatorInsets: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    scrollPerfTag: true,
-    scrollToOverflowEnabled: true,
-    scrollsToTop: true,
-    sendMomentumEvents: true,
-    showsHorizontalScrollIndicator: true,
-    showsVerticalScrollIndicator: true,
-    snapToAlignment: true,
-    snapToEnd: true,
-    snapToInterval: true,
-    snapToOffsets: true,
-    snapToStart: true,
-    zoomScale: true,
-  },
-};
-
-module.exports = (ScrollViewViewConfig: PartialViewConfig);