react-native 0.70.3 → 0.71.0-rc.0

package/Libraries/StyleSheet/processColor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+
+import {ColorValue, OpaqueColorValue} from './StyleSheet';
+
+export type ProcessedColorValue = number | OpaqueColorValue;
+
+export function processColor(
+  color?: number | ColorValue,
+): ProcessedColorValue | null | undefined;

package/Libraries/StyleSheet/processColor.js

@@ -10,13 +10,12 @@
 
 'use strict';
 
-const Platform = require('../Utilities/Platform');
+import type {NativeColorValue} from './PlatformColorValueTypes';
+import type {ColorValue} from './StyleSheet';
 
+const Platform = require('../Utilities/Platform');
 const normalizeColor = require('./normalizeColor');
 
-import type {ColorValue} from './StyleSheet';
-import type {NativeColorValue} from './PlatformColorValueTypes';
-
 export type ProcessedColorValue = number | NativeColorValue;
 
 /* eslint no-bitwise: 0 */

package/Libraries/StyleSheet/processColorArray.js

@@ -11,6 +11,7 @@
 'use strict';
 
 import type {ColorValue} from './StyleSheet';
+
 import processColor, {type ProcessedColorValue} from './processColor';
 
 const TRANSPARENT = 0; // rgba(0, 0, 0, 0)

package/Libraries/StyleSheet/processFontVariant.js

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import type {____FontVariantArray_Internal} from './StyleSheetTypes';
+
+function processFontVariant(
+  fontVariant: ____FontVariantArray_Internal | string,
+): ?____FontVariantArray_Internal {
+  if (Array.isArray(fontVariant)) {
+    return fontVariant;
+  }
+
+  // $FlowFixMe[incompatible-type]
+  const match: ?____FontVariantArray_Internal = fontVariant
+    .split(' ')
+    .filter(Boolean);
+
+  return match;
+}
+
+module.exports = processFontVariant;

package/Libraries/StyleSheet/processTransform.js

@@ -10,11 +10,8 @@
 
 'use strict';
 
-const MatrixMath = require('../Utilities/MatrixMath');
-const Platform = require('../Utilities/Platform');
-
-const invariant = require('invariant');
 const stringifySafe = require('../Utilities/stringifySafe').default;
+const invariant = require('invariant');
 
 /**
  * Generate a transform matrix based on the provided transforms, and use that
@@ -25,118 +22,130 @@ const stringifySafe = require('../Utilities/stringifySafe').default;
  * interface to native code.
  */
 function processTransform(
-  transform: Array<Object>,
+  transform: Array<Object> | string,
 ): Array<Object> | Array<number> {
+  if (typeof transform === 'string') {
+    const regex = new RegExp(/(\w+)\(([^)]+)\)/g);
+    let transformArray: Array<Object> = [];
+    let matches;
+
+    while ((matches = regex.exec(transform))) {
+      const {key, value} = _getKeyAndValueFromCSSTransform(
+        matches[1],
+        matches[2],
+      );
+
+      if (value !== undefined) {
+        transformArray.push({[key]: value});
+      }
+    }
+    transform = transformArray;
+  }
+
   if (__DEV__) {
     _validateTransforms(transform);
   }
 
-  // Android & iOS implementations of transform property accept the list of
-  // transform properties as opposed to a transform Matrix. This is necessary
-  // to control transform property updates completely on the native thread.
-  if (Platform.OS === 'android' || Platform.OS === 'ios') {
-    return transform;
-  }
+  return transform;
+}
+
+const _getKeyAndValueFromCSSTransform: (
+  key:
+    | string
+    | $TEMPORARY$string<'matrix'>
+    | $TEMPORARY$string<'perspective'>
+    | $TEMPORARY$string<'rotate'>
+    | $TEMPORARY$string<'rotateX'>
+    | $TEMPORARY$string<'rotateY'>
+    | $TEMPORARY$string<'rotateZ'>
+    | $TEMPORARY$string<'scale'>
+    | $TEMPORARY$string<'scaleX'>
+    | $TEMPORARY$string<'scaleY'>
+    | $TEMPORARY$string<'skewX'>
+    | $TEMPORARY$string<'skewY'>
+    | $TEMPORARY$string<'translate'>
+    | $TEMPORARY$string<'translate3d'>
+    | $TEMPORARY$string<'translateX'>
+    | $TEMPORARY$string<'translateY'>,
+  args: string,
+) => {key: string, value?: number[] | number | string} = (key, args) => {
+  const argsWithUnitsRegex = new RegExp(/([+-]?\d+(\.\d+)?)([a-zA-Z]+)?/g);
 
-  const result = MatrixMath.createIdentityMatrix();
+  switch (key) {
+    case 'matrix':
+      return {key, value: args.match(/[+-]?\d+(\.\d+)?/g)?.map(Number)};
+    case 'translate':
+    case 'translate3d':
+      const parsedArgs = [];
+      let missingUnitOfMeasurement = false;
 
-  transform.forEach(transformation => {
-    const key = Object.keys(transformation)[0];
-    const value = transformation[key];
+      let matches;
+      while ((matches = argsWithUnitsRegex.exec(args))) {
+        const value = Number(matches[1]);
+        const unitOfMeasurement = matches[3];
 
-    switch (key) {
-      case 'matrix':
-        MatrixMath.multiplyInto(result, result, value);
-        break;
-      case 'perspective':
-        _multiplyTransform(result, MatrixMath.reusePerspectiveCommand, [value]);
-        break;
-      case 'rotateX':
-        _multiplyTransform(result, MatrixMath.reuseRotateXCommand, [
-          _convertToRadians(value),
-        ]);
-        break;
-      case 'rotateY':
-        _multiplyTransform(result, MatrixMath.reuseRotateYCommand, [
-          _convertToRadians(value),
-        ]);
-        break;
-      case 'rotate':
-      case 'rotateZ':
-        _multiplyTransform(result, MatrixMath.reuseRotateZCommand, [
-          _convertToRadians(value),
-        ]);
-        break;
-      case 'scale':
-        _multiplyTransform(result, MatrixMath.reuseScaleCommand, [value]);
-        break;
-      case 'scaleX':
-        _multiplyTransform(result, MatrixMath.reuseScaleXCommand, [value]);
-        break;
-      case 'scaleY':
-        _multiplyTransform(result, MatrixMath.reuseScaleYCommand, [value]);
-        break;
-      case 'translate':
-        _multiplyTransform(result, MatrixMath.reuseTranslate3dCommand, [
-          value[0],
-          value[1],
-          value[2] || 0,
-        ]);
-        break;
-      case 'translateX':
-        _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [
-          value,
-          0,
-        ]);
-        break;
-      case 'translateY':
-        _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [
-          0,
-          value,
-        ]);
-        break;
-      case 'skewX':
-        _multiplyTransform(result, MatrixMath.reuseSkewXCommand, [
-          _convertToRadians(value),
-        ]);
-        break;
-      case 'skewY':
-        _multiplyTransform(result, MatrixMath.reuseSkewYCommand, [
-          _convertToRadians(value),
-        ]);
-        break;
-      default:
-        throw new Error('Invalid transform name: ' + key);
-    }
-  });
+        if (value !== 0 && !unitOfMeasurement) {
+          missingUnitOfMeasurement = true;
+        }
 
-  return result;
-}
+        parsedArgs.push(value);
+      }
 
-/**
- * Performs a destructive operation on a transform matrix.
- */
-/* $FlowFixMe[missing-this-annot] The 'this' type annotation(s) required by
- * Flow's LTI update could not be added via codemod */
-function _multiplyTransform(
-  result: Array<number>,
-  matrixMathFunction: Function,
-  args: Array<number>,
-): void {
-  const matrixToApply = MatrixMath.createIdentityMatrix();
-  const argsWithIdentity = [matrixToApply].concat(args);
-  matrixMathFunction.apply(this, argsWithIdentity);
-  MatrixMath.multiplyInto(result, result, matrixToApply);
-}
+      if (__DEV__) {
+        invariant(
+          !missingUnitOfMeasurement,
+          `Transform with key ${key} must have units unless the provided value is 0, found %s`,
+          `${key}(${args})`,
+        );
 
-/**
- * Parses a string like '0.5rad' or '60deg' into radians expressed in a float.
- * Note that validation on the string is done in `_validateTransform()`.
- */
-function _convertToRadians(value: string): number {
-  const floatValue = parseFloat(value);
-  return value.indexOf('rad') > -1 ? floatValue : (floatValue * Math.PI) / 180;
-}
+        if (key === 'translate') {
+          invariant(
+            parsedArgs?.length === 1 || parsedArgs?.length === 2,
+            'Transform with key translate must be an string with 1 or 2 parameters, found %s: %s',
+            parsedArgs?.length,
+            `${key}(${args})`,
+          );
+        } else {
+          invariant(
+            parsedArgs?.length === 3,
+            'Transform with key translate3d must be an string with 3 parameters, found %s: %s',
+            parsedArgs?.length,
+            `${key}(${args})`,
+          );
+        }
+      }
+
+      if (parsedArgs?.length === 1) {
+        parsedArgs.push(0);
+      }
+
+      return {key: 'translate', value: parsedArgs};
+    case 'translateX':
+    case 'translateY':
+    case 'perspective':
+      const argMatches = argsWithUnitsRegex.exec(args);
+
+      if (!argMatches?.length) {
+        return {key, value: undefined};
+      }
+
+      const value = Number(argMatches[1]);
+      const unitOfMeasurement = argMatches[3];
+
+      if (__DEV__) {
+        invariant(
+          value === 0 || unitOfMeasurement,
+          `Transform with key ${key} must have units unless the provided value is 0, found %s`,
+          `${key}(${args})`,
+        );
+      }
+
+      return {key, value};
+
+    default:
+      return {key, value: !isNaN(args) ? Number(args) : args};
+  }
+};
 
 function _validateTransforms(transform: Array<Object>): void {
   transform.forEach(transformation => {

package/Libraries/StyleSheet/splitLayoutProps.js

@@ -49,13 +49,18 @@ export default function splitLayoutProps(props: ?____ViewStyle_Internal): {
         case 'bottom':
         case 'top':
         case 'transform':
+        case 'rowGap':
+        case 'columnGap':
+        case 'gap':
           // $FlowFixMe[cannot-write]
           // $FlowFixMe[incompatible-use]
+          // $FlowFixMe[prop-missing]
           outer[prop] = props[prop];
           break;
         default:
           // $FlowFixMe[cannot-write]
           // $FlowFixMe[incompatible-use]
+          // $FlowFixMe[prop-missing]
           inner[prop] = props[prop];
           break;
       }

package/Libraries/SurfaceBackedComponent/RCTSurfaceBackedComponent.mm

@@ -12,8 +12,8 @@
 #import <ComponentKit/CKComponentSubclass.h>
 #import <ComponentKit/CKOverlayLayoutComponent.h>
 #import <RCTSurfaceHostingComponent/RCTSurfaceHostingComponent.h>
-#import <React/RCTSurface.h>
 #import <React/RCTFabricSurface.h>
+#import <React/RCTSurface.h>
 
 #import "RCTSurfaceBackedComponentState.h"
 
@@ -42,35 +42,32 @@
     id<RCTSurfaceProtocol> surface;
     if (surfacePresenter) {
       surface = [[RCTFabricSurface alloc] initWithSurfacePresenter:surfacePresenter
-                                              moduleName:moduleName
-                                              initialProperties:adjustedProperties];
+                                                        moduleName:moduleName
+                                                 initialProperties:adjustedProperties];
     } else {
-      surface = [[RCTSurface alloc] initWithBridge:bridge
-                                moduleName:moduleName
-                         initialProperties:adjustedProperties];
+      surface = [[RCTSurface alloc] initWithBridge:bridge moduleName:moduleName initialProperties:adjustedProperties];
     }
     [surface start];
 
     state = [RCTSurfaceBackedComponentState newWithSurface:surface];
 
     CKComponentScope::replaceState(scope, state);
-  }
-  else {
+  } else {
     if (![state.surface.properties isEqualToDictionary:adjustedProperties]) {
       state.surface.properties = adjustedProperties;
     }
   }
 
-  RCTSurfaceHostingComponent *surfaceHostingComponent =
-    [RCTSurfaceHostingComponent newWithSurface:state.surface
-                                       options:options];
+  RCTSurfaceHostingComponent *surfaceHostingComponent = [RCTSurfaceHostingComponent newWithSurface:state.surface
+                                                                                           options:options];
 
   CKComponent *component;
   if (options.activityIndicatorComponentFactory == nil || RCTSurfaceStageIsRunning(state.surface.stage)) {
     component = surfaceHostingComponent;
   } else {
     component = [[CKOverlayLayoutComponent alloc] initWithComponent:surfaceHostingComponent
-                                                            overlay:options.activityIndicatorComponentFactory()];
+                                                            overlay:options.activityIndicatorComponentFactory()
+                                               accessibilityContext:{}];
   }
 
   return [super newWithComponent:component];

package/Libraries/SurfaceBackedComponent/RCTSurfaceBackedComponentState.h

@@ -9,7 +9,7 @@
 
 @protocol RCTSurfaceProtocol;
 
-@interface RCTSurfaceBackedComponentState: NSObject
+@interface RCTSurfaceBackedComponentState : NSObject
 
 @property (atomic, readonly, strong) id<RCTSurfaceProtocol> surface;
 

package/Libraries/SurfaceHostingComponent/RCTSurfaceHostingComponent.mm

@@ -37,15 +37,13 @@
   RCTSurfaceHostingComponentState *const state = scope.state();
 
   RCTSurfaceHostingComponentState *const newState =
-    [RCTSurfaceHostingComponentState newWithStage:surface.stage
-                                     intrinsicSize:surface.intrinsicSize];
+      [RCTSurfaceHostingComponentState newWithStage:surface.stage intrinsicSize:surface.intrinsicSize];
 
   if (![state isEqual:newState]) {
     CKComponentScope::replaceState(scope, newState);
   }
 
-  RCTSurfaceHostingComponent *const component =
-    [super newWithView:{[UIView class]} size:{}];
+  RCTSurfaceHostingComponent *const component = [super newWithView:{[UIView class]} size:{}];
 
   if (component) {
     component->_state = scope.state();
@@ -72,15 +70,14 @@
   // interop compatibilities of React Native which will enable us granularly
   // control React Native mounting blocks and, as a result, implement
   // truly synchronous mounting stage between React Native and ComponentKit.
-  [_surface setMinimumSize:constrainedSize.min
-               maximumSize:constrainedSize.max];
+  [_surface setMinimumSize:constrainedSize.min maximumSize:constrainedSize.max];
 
   // Just in case of the very first building pass, we give React Native a chance
   // to prepare its internals for coming synchronous measuring.
   if ([_surface isKindOfClass:[RCTSurface class]]) {
     // Legacy Pre-Fabric Surface
     [(RCTSurface *)_surface synchronouslyWaitForStage:RCTSurfaceStageSurfaceDidInitialLayout
-                                      timeout:_options.synchronousLayoutingTimeout];
+                                              timeout:_options.synchronousLayoutingTimeout];
   } else if ([_surface isKindOfClass:[RCTFabricSurface class]]) {
     // Fabric Surface
     // Hack: Increase timeout because RCTFabricSurface stage will be RCTSurfaceStageSurfaceDidInitialLayout
@@ -94,10 +91,8 @@
 
   CGSize fittingSize = CGSizeZero;
   if (_surface.stage & RCTSurfaceStageSurfaceDidInitialLayout) {
-    fittingSize = [_surface sizeThatFitsMinimumSize:constrainedSize.min
-                                        maximumSize:constrainedSize.max];
-  }
-  else {
+    fittingSize = [_surface sizeThatFitsMinimumSize:constrainedSize.min maximumSize:constrainedSize.max];
+  } else {
     fittingSize = _options.activityIndicatorSize;
   }
 
@@ -109,9 +104,9 @@
 {
   if (_options.boundsAnimations && (previousComponent->_state.stage != _state.stage)) {
     return {
-      .mode = CKComponentBoundsAnimationModeDefault,
-      .duration = 0.25,
-      .options = UIViewAnimationOptionCurveEaseInOut,
+        .mode = CKComponentBoundsAnimationModeDefault,
+        .duration = 0.25,
+        .options = UIViewAnimationOptionCurveEaseInOut,
     };
   }
 

package/Libraries/SurfaceHostingComponent/RCTSurfaceHostingComponentController.mm

@@ -17,7 +17,7 @@
 #import "RCTSurfaceHostingComponent.h"
 #import "RCTSurfaceHostingComponentState.h"
 
-@interface RCTSurfaceHostingComponentController() <RCTSurfaceDelegate>
+@interface RCTSurfaceHostingComponentController () <RCTSurfaceDelegate>
 @end
 
 @implementation RCTSurfaceHostingComponentController {
@@ -83,11 +83,12 @@
     if (!strongSelf) {
       return;
     }
-    
-    [strongSelf.component updateState:^(RCTSurfaceHostingComponentState *state) {
-      return [RCTSurfaceHostingComponentState newWithStage:state.stage
-                                             intrinsicSize:intrinsicSize];
-    } mode:[strongSelf suitableStateUpdateMode]];
+
+    [strongSelf.component
+        updateState:^(RCTSurfaceHostingComponentState *state) {
+          return [RCTSurfaceHostingComponentState newWithStage:state.stage intrinsicSize:intrinsicSize];
+        }
+               mode:[strongSelf suitableStateUpdateMode]];
   });
 }
 
@@ -99,17 +100,20 @@
     if (!strongSelf) {
       return;
     }
-    
-    [strongSelf.component updateState:^(RCTSurfaceHostingComponentState *state) {
-      return [RCTSurfaceHostingComponentState newWithStage:stage
-                                             intrinsicSize:state.intrinsicSize];
-    } mode:[strongSelf suitableStateUpdateMode]];
+
+    [strongSelf.component
+        updateState:^(RCTSurfaceHostingComponentState *state) {
+          return [RCTSurfaceHostingComponentState newWithStage:stage intrinsicSize:state.intrinsicSize];
+        }
+               mode:[strongSelf suitableStateUpdateMode]];
   });
 }
 
 - (CKUpdateMode)suitableStateUpdateMode
 {
-  return ((RCTSurfaceHostingComponent *)self.component).options.synchronousStateUpdates && RCTIsMainQueue() ? CKUpdateModeSynchronous : CKUpdateModeAsynchronous;
+  return ((RCTSurfaceHostingComponent *)self.component).options.synchronousStateUpdates && RCTIsMainQueue()
+      ? CKUpdateModeSynchronous
+      : CKUpdateModeAsynchronous;
 }
 
 - (void)mountSurfaceView

package/Libraries/SurfaceHostingComponent/RCTSurfaceHostingComponentOptions.h

@@ -9,7 +9,7 @@
 
 #import <ComponentKit/CKComponent.h>
 
-typedef CKComponent *(^RCTSurfaceHostingComponentOptionsActivityIndicatorComponentFactory)();
+typedef CKComponent * (^RCTSurfaceHostingComponentOptionsActivityIndicatorComponentFactory)();
 
 struct RCTSurfaceHostingComponentOptions {
   NSTimeInterval synchronousLayoutingTimeout = 0.350;

package/Libraries/SurfaceHostingComponent/RCTSurfaceHostingComponentState.h

@@ -9,12 +9,11 @@
 
 #import <React/RCTSurfaceStage.h>
 
-@interface RCTSurfaceHostingComponentState: NSObject
+@interface RCTSurfaceHostingComponentState : NSObject
 
 @property (nonatomic, readonly, assign) CGSize intrinsicSize;
 @property (nonatomic, readonly, assign) RCTSurfaceStage stage;
 
-+ (instancetype)newWithStage:(RCTSurfaceStage)stage
-               intrinsicSize:(CGSize)intrinsicSize;
++ (instancetype)newWithStage:(RCTSurfaceStage)stage intrinsicSize:(CGSize)intrinsicSize;
 
 @end

package/Libraries/SurfaceHostingComponent/RCTSurfaceHostingComponentState.mm

@@ -9,15 +9,12 @@
 
 @implementation RCTSurfaceHostingComponentState
 
-+ (instancetype)newWithStage:(RCTSurfaceStage)stage
-               intrinsicSize:(CGSize)intrinsicSize
++ (instancetype)newWithStage:(RCTSurfaceStage)stage intrinsicSize:(CGSize)intrinsicSize
 {
   return [[self alloc] initWithStage:stage intrinsicSize:intrinsicSize];
 }
 
-
-- (instancetype)initWithStage:(RCTSurfaceStage)stage
-                intrinsicSize:(CGSize)intrinsicSize
+- (instancetype)initWithStage:(RCTSurfaceStage)stage intrinsicSize:(CGSize)intrinsicSize
 {
   if (self = [super init]) {
     _stage = stage;
@@ -33,9 +30,7 @@
     return YES;
   }
 
-  return
-    _stage == other->_stage &&
-    CGSizeEqualToSize(_intrinsicSize, other->_intrinsicSize);
+  return _stage == other->_stage && CGSizeEqualToSize(_intrinsicSize, other->_intrinsicSize);
 }
 
 @end

package/Libraries/Text/BaseText/RCTBaseTextShadowView.h

@@ -14,8 +14,10 @@ NS_ASSUME_NONNULL_BEGIN
 extern NSString *const RCTBaseTextShadowViewEmbeddedShadowViewAttributeName;
 
 @interface RCTBaseTextShadowView : RCTShadowView {
-  @protected NSAttributedString *_Nullable cachedAttributedText;
-  @protected RCTTextAttributes *_Nullable cachedTextAttributes;
+ @protected
+  NSAttributedString *_Nullable cachedAttributedText;
+ @protected
+  RCTTextAttributes *_Nullable cachedTextAttributes;
 }
 
 @property (nonatomic, strong) RCTTextAttributes *textAttributes;

package/Libraries/Text/BaseText/RCTBaseTextShadowView.m

@@ -12,7 +12,8 @@
 #import <React/RCTRawTextShadowView.h>
 #import <React/RCTVirtualTextShadowView.h>
 
-NSString *const RCTBaseTextShadowViewEmbeddedShadowViewAttributeName = @"RCTBaseTextShadowViewEmbeddedShadowViewAttributeName";
+NSString *const RCTBaseTextShadowViewEmbeddedShadowViewAttributeName =
+    @"RCTBaseTextShadowViewEmbeddedShadowViewAttributeName";
 
 static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
 {
@@ -22,9 +23,8 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
   // the outermost text node which has a Yoga node and then Yoga will take over
   // the dirty signal propagation.
   RCTShadowView *inlineView = (__bridge RCTShadowView *)YGNodeGetContext(node);
-  RCTBaseTextShadowView *baseTextShadowView =
-    (RCTBaseTextShadowView *)inlineView.reactSuperview;
-  
+  RCTBaseTextShadowView *baseTextShadowView = (RCTBaseTextShadowView *)inlineView.reactSuperview;
+
   [baseTextShadowView dirtyLayout];
 }
 
@@ -50,9 +50,9 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
 - (void)insertReactSubview:(RCTShadowView *)subview atIndex:(NSInteger)index
 {
   [super insertReactSubview:subview atIndex:index];
-  
+
   [self dirtyLayout];
-  
+
   if (![subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
     YGNodeSetDirtiedFunc(subview.yogaNode, RCTInlineViewYogaNodeDirtied);
   }
@@ -63,9 +63,9 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
   if (![subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
     YGNodeSetDirtiedFunc(subview.yogaNode, NULL);
   }
-  
+
   [self dirtyLayout];
-  
+
   [super removeReactSubview:subview];
 }
 
@@ -97,8 +97,8 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
       NSString *text = rawTextShadowView.text;
       if (text) {
         NSAttributedString *rawTextAttributedString =
-          [[NSAttributedString alloc] initWithString:[textAttributes applyTextAttributesToText:text]
-                                          attributes:textAttributes.effectiveTextAttributes];
+            [[NSAttributedString alloc] initWithString:[textAttributes applyTextAttributesToText:text]
+                                            attributes:textAttributes.effectiveTextAttributes];
         [attributedText appendAttributedString:rawTextAttributedString];
       }
       continue;
@@ -108,7 +108,7 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
     if ([shadowView isKindOfClass:[RCTBaseTextShadowView class]]) {
       RCTBaseTextShadowView *baseTextShadowView = (RCTBaseTextShadowView *)shadowView;
       NSAttributedString *baseTextAttributedString =
-        [baseTextShadowView attributedTextWithBaseTextAttributes:textAttributes];
+          [baseTextShadowView attributedTextWithBaseTextAttributes:textAttributes];
       [attributedText appendAttributedString:baseTextAttributedString];
       continue;
     }
@@ -117,7 +117,8 @@ static void RCTInlineViewYogaNodeDirtied(YGNodeRef node)
     NSTextAttachment *attachment = [NSTextAttachment new];
     NSMutableAttributedString *embeddedShadowViewAttributedString = [NSMutableAttributedString new];
     [embeddedShadowViewAttributedString beginEditing];
-    [embeddedShadowViewAttributedString appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
+    [embeddedShadowViewAttributedString
+        appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
     [embeddedShadowViewAttributedString addAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
                                                value:shadowView
                                                range:(NSRange){0, embeddedShadowViewAttributedString.length}];

package/Libraries/Text/BaseText/RCTBaseTextViewManager.m

@@ -42,6 +42,7 @@ RCT_REMAP_SHADOW_PROPERTY(letterSpacing, textAttributes.letterSpacing, CGFloat)
 RCT_REMAP_SHADOW_PROPERTY(lineHeight, textAttributes.lineHeight, CGFloat)
 RCT_REMAP_SHADOW_PROPERTY(textAlign, textAttributes.alignment, NSTextAlignment)
 RCT_REMAP_SHADOW_PROPERTY(writingDirection, textAttributes.baseWritingDirection, NSWritingDirection)
+RCT_REMAP_SHADOW_PROPERTY(lineBreakStrategyIOS, textAttributes.lineBreakStrategy, NSLineBreakStrategy)
 // Decoration
 RCT_REMAP_SHADOW_PROPERTY(textDecorationColor, textAttributes.textDecorationColor, UIColor)
 RCT_REMAP_SHADOW_PROPERTY(textDecorationStyle, textAttributes.textDecorationStyle, NSUnderlineStyle)