react-native 0.69.0-rc.6 → 0.70.0-rc.0

package/Libraries/vendor/emitter/__flowtests__/EventEmitter-flowtest.js

@@ -1,5 +1,8 @@
 /**
- * (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+ * 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
@@ -7,119 +10,72 @@
 
 import EventEmitter from '../EventEmitter';
 
-type MyEvents = {
-  noArgsEvent: [],
-  stringEvent: [string],
-  numberEvent: [number],
-  anotherNumberEvent: [number],
-  objectAndBooleanEvent: [{prop: string}, boolean],
-};
-
-export function testBaseEventEmitterInstance() {
-  const emitter = new EventEmitter<MyEvents>();
-
-  emitter.addListener('noArgsEvent', expectedUndefined => {
-    (expectedUndefined: void);
-  });
-
-  emitter.addListener('stringEvent', expectedString => {
-    (expectedString: string);
-  });
-
-  emitter.addListener('numberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener('anotherNumberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener(
-    'objectAndBooleanEvent',
-    (expectedObject, expectedBoolean, unexpectedArg) => {
-      (expectedObject: {prop: string});
-      (expectedBoolean: boolean);
-      (unexpectedArg: void);
-    },
-  );
-
-  // $FlowExpectedError[prop-missing]
-  emitter.addListener('unexpectedEvent', () => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('noArgsEvent', (value: number) => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('numberEvent', (value: string) => {});
-
-  emitter.emit('noArgsEvent');
-  emitter.emit('stringEvent', 'value');
-  emitter.emit('numberEvent', 4);
-  emitter.emit('anotherNumberEvent', 4);
-  emitter.emit('objectAndBooleanEvent', {prop: 'value'}, true);
-}
-
-export function testSubclass() {
-  // $FlowExpectedError[incompatible-type-arg]
-  class EmitterWithUndefinedDefinition extends EventEmitter<void> {}
-
-  // $FlowExpectedError[incompatible-type-arg]
-  class EmitterWithNumberDefinition extends EventEmitter<number> {}
-
-  class EmitterWithInvalidDefinitions extends EventEmitter<{
-    foo: number,
-  }> {}
-
-  const emitter = new EmitterWithInvalidDefinitions();
-  // $FlowExpectedError[not-an-array]
-  // $FlowExpectedError[incompatible-call]
-  emitter.emit('foo');
-
-  class EmitterWithValidDefinitions extends EventEmitter<MyEvents> {}
-}
-
-export function testSubclassInstance() {
-  class MyEmitter extends EventEmitter<MyEvents> {}
-
-  const emitter = new MyEmitter();
-
-  emitter.addListener('noArgsEvent', expectedUndefined => {
-    (expectedUndefined: void);
-  });
-
-  emitter.addListener('stringEvent', expectedString => {
-    (expectedString: string);
-  });
-
-  emitter.addListener('numberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener('anotherNumberEvent', expectedNumber => {
-    (expectedNumber: number);
-  });
-
-  emitter.addListener(
-    'objectAndBooleanEvent',
-    (expectedObject, expectedBoolean, unexpectedArg) => {
-      (expectedObject: {prop: string});
-      (expectedBoolean: boolean);
-      (unexpectedArg: void);
-    },
-  );
-
-  // $FlowExpectedError[prop-missing]
-  emitter.addListener('unexpectedEvent', () => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('noArgsEvent', (value: number) => {});
-
-  // $FlowExpectedError[incompatible-call]
-  emitter.addListener('numberEvent', (value: string) => {});
-
-  emitter.emit('noArgsEvent');
-  emitter.emit('stringEvent', 'value');
-  emitter.emit('numberEvent', 4);
-  emitter.emit('anotherNumberEvent', 4);
-  emitter.emit('objectAndBooleanEvent', {prop: 'value'}, true);
-}
+const emitter = new EventEmitter<{
+  void: [],
+  string: [string],
+  strings: [string, string],
+  error: [Error],
+}>();
+
+const subscription = emitter.addListener('void', unknown => {
+  (unknown: void);
+});
+subscription.remove();
+
+emitter.addListener('string', foo => {
+  (foo: string);
+});
+emitter.addListener('strings', (foo, bar) => {
+  (foo: string);
+  (bar: string);
+});
+emitter.addListener('error', error => {
+  (error: Error);
+});
+
+emitter.emit('void');
+emitter.emit('string', 'foo');
+emitter.emit('strings', 'foo', 'bar');
+emitter.emit('error', new Error());
+
+emitter.removeAllListeners('void');
+emitter.removeAllListeners('string');
+emitter.removeAllListeners('strings');
+emitter.removeAllListeners('error');
+emitter.removeAllListeners();
+
+emitter.listenerCount('void');
+emitter.listenerCount('string');
+emitter.listenerCount('strings');
+emitter.listenerCount('error');
+
+// $FlowExpectedError[prop-missing]
+emitter.addListener('does-not-exist', () => {
+  // ...
+});
+
+// $FlowExpectedError[prop-missing]
+subscription.context;
+// $FlowExpectedError[prop-missing]
+subscription.listener;
+// $FlowExpectedError[prop-missing]
+subscription.once;
+
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('void', undefined);
+// $FlowExpectedError[incompatible-call]
+emitter.emit('string', 123);
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('strings', 'foo');
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('strings', 'foo', 'bar', 'baz');
+// $FlowExpectedError[invalid-tuple-arity]
+emitter.emit('error');
+// $FlowExpectedError[prop-missing]
+emitter.emit('does-not-exist');
+
+// $FlowExpectedError[prop-missing]
+emitter.removeAllListeners('does-not-exist');
+
+// $FlowExpectedError[prop-missing]
+emitter.listenerCount('does-not-exist');

package/README.md

@@ -67,7 +67,7 @@ React Native is developed and supported by many companies and individual core co
 
 ## 📋 Requirements
 
-React Native apps may target iOS 11.0 and Android 5.0 (API 21) or newer. You may use Windows, macOS, or Linux as your development operating system, though building and running iOS apps is limited to macOS. Tools like [Expo](https://expo.io) can be used to work around this.
+React Native apps may target iOS 12.4 and Android 5.0 (API 21) or newer. You may use Windows, macOS, or Linux as your development operating system, though building and running iOS apps is limited to macOS. Tools like [Expo](https://expo.io) can be used to work around this.
 
 ## 🎉 Building your first React Native app
 

package/React/Base/RCTAssert.h

@@ -178,24 +178,26 @@ RCT_EXTERN NSString *RCTFormatStackTrace(NSArray<NSDictionary<NSString *, id> *>
 // MARK: - New Architecture Validation
 
 typedef enum {
-  RCTNotAllowedValidationDisabled = 0,
-  RCTNotAllowedInAppWideFabric = 1,
-  RCTNotAllowedInBridgeless = 2,
+  RCTNotAllowedInBridgeless = 1,
+  RCTNotAllowedInFabricWithoutLegacy = 2,
+  RCTNotAllowedValidationDisabled = 3,
 } RCTNotAllowedValidation;
 
 /**
+ * // TODO: (T125626909) Only validate legacy architecture usages in Bridgeless mode, not Bridged Fabric mode
+ *
  * Ensure runtime assumptions holds for the new architecture by reporting when assumptions are violated.
  * Note: this is work in progress.
  *
- * When type is RCTNotAllowedInAppWideFabric, validate Fabric assumptions in Bridge or Bridgeless mode.
+ * When level is RCTNotAllowedInFabricWithoutLegacy, validate Fabric assumptions.
  * i.e. Report legacy pre-Fabric call sites that should not be used while Fabric is enabled on all surfaces.
  *
- * When type is RCTNotAllowedInBridgeless, validate Bridgeless assumptions, in Bridgeless mode only.
+ * When level is RCTNotAllowedInBridgeless, validate Fabric or Bridgeless assumptions.
  * i.e. Report Bridge call sites that should not be used while Bridgeless mode is enabled.
  *
  * Note: enabling this at runtime is not early enough to report issues within ObjC class +load execution.
  */
-__attribute__((used)) RCT_EXTERN void RCTNewArchitectureValidationSetEnabled(RCTNotAllowedValidation type);
+__attribute__((used)) RCT_EXTERN void RCTNewArchitectureSetMinValidationLevel(RCTNotAllowedValidation level);
 
 // When new architecture validation reporting is enabled, trigger an assertion and crash.
 __attribute__((used)) RCT_EXTERN void
@@ -208,3 +210,7 @@ RCTErrorNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSSt
 // When ready, switch to stricter variant above.
 __attribute__((used)) RCT_EXTERN void
 RCTLogNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra);
+// A placeholder for callsites that frequently fail validation.
+// When ready, switch to stricter variant above.
+__attribute__((used)) RCT_EXTERN void
+RCTNewArchitectureValidationPlaceholder(RCTNotAllowedValidation type, id context, NSString *extra);

package/React/Base/RCTAssert.m

@@ -234,18 +234,18 @@ RCTFatalExceptionHandler RCTGetFatalExceptionHandler(void)
 
 // MARK: - New Architecture Validation - Enable Reporting
 
-#if RCT_NEW_ARCHITECTURE
-static RCTNotAllowedValidation validationReportingEnabled = RCTNotAllowedInBridgeless;
+#if RCT_ONLY_NEW_ARCHITECTURE
+static RCTNotAllowedValidation minValidationLevel = RCTNotAllowedInBridgeless;
 #else
-static RCTNotAllowedValidation validationReportingEnabled = RCTNotAllowedValidationDisabled;
+static RCTNotAllowedValidation minValidationLevel = RCTNotAllowedValidationDisabled;
 #endif
 
-__attribute__((used)) RCT_EXTERN void RCTNewArchitectureValidationSetEnabled(RCTNotAllowedValidation type)
+__attribute__((used)) RCT_EXTERN void RCTNewArchitectureSetMinValidationLevel(RCTNotAllowedValidation level)
 {
-#if RCT_NEW_ARCHITECTURE
+#if RCT_ONLY_NEW_ARCHITECTURE
   // Cannot disable the reporting in this mode.
 #else
-  validationReportingEnabled = type;
+  minValidationLevel = level;
 #endif
 }
 
@@ -253,16 +253,7 @@ __attribute__((used)) RCT_EXTERN void RCTNewArchitectureValidationSetEnabled(RCT
 
 static BOOL shouldEnforceValidation(RCTNotAllowedValidation type)
 {
-  switch (type) {
-    case RCTNotAllowedInAppWideFabric:
-      return validationReportingEnabled == RCTNotAllowedInBridgeless ||
-          validationReportingEnabled == RCTNotAllowedInAppWideFabric;
-    case RCTNotAllowedInBridgeless:
-      return validationReportingEnabled == RCTNotAllowedInBridgeless;
-    case RCTNotAllowedValidationDisabled:
-      return NO;
-  }
-  return NO;
+  return type >= minValidationLevel;
 }
 
 static NSString *stringDescribingContext(id context)
@@ -284,8 +275,8 @@ static NSString *validationMessage(RCTNotAllowedValidation type, id context, NSS
   switch (type) {
     case RCTNotAllowedValidationDisabled:
       RCTAssert(0, @"RCTNotAllowedValidationDisabled not a validation type.");
-      break;
-    case RCTNotAllowedInAppWideFabric:
+      return nil;
+    case RCTNotAllowedInFabricWithoutLegacy:
       notAllowedType = @"Fabric";
       break;
     case RCTNotAllowedInBridgeless:
@@ -300,31 +291,55 @@ static NSString *validationMessage(RCTNotAllowedValidation type, id context, NSS
                                  extra ?: @""];
 }
 
-// MARK: - New Architecture Validation - Public
-
-void RCTEnforceNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra)
+static void
+newArchitectureValidationInternal(RCTLogLevel level, RCTNotAllowedValidation type, id context, NSString *extra)
 {
   if (!shouldEnforceValidation(type)) {
     return;
   }
 
-  RCTAssert(0, @"%@", validationMessage(type, context, extra));
+  NSString *msg = validationMessage(type, context, extra);
+  if (msg) {
+    switch (level) {
+      case RCTLogLevelInfo:
+        RCTLogInfo(@"%@", msg);
+        break;
+      case RCTLogLevelError:
+        RCTLogError(@"%@", msg);
+        break;
+      case RCTLogLevelFatal:
+        RCTAssert(0, @"%@", msg);
+        break;
+      default:
+        RCTAssert(0, @"New architecture validation is only for info, error, and fatal levels.");
+    }
+  }
 }
 
-void RCTErrorNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra)
+// MARK: - New Architecture Validation - Public
+
+void RCTEnforceNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra)
 {
-  if (!shouldEnforceValidation(type)) {
-    return;
-  }
+  newArchitectureValidationInternal(RCTLogLevelFatal, type, context, extra);
+}
 
-  RCTLogError(@"%@", validationMessage(type, context, extra));
+void RCTErrorNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra)
+{
+#if RCT_ONLY_NEW_ARCHITECTURE
+  newArchitectureValidationInternal(RCTLogLevelFatal, type, context, extra);
+#else
+  newArchitectureValidationInternal(RCTLogLevelError, type, context, extra);
+#endif
 }
 
 void RCTLogNewArchitectureValidation(RCTNotAllowedValidation type, id context, NSString *extra)
 {
-  if (!shouldEnforceValidation(type)) {
-    return;
-  }
+  newArchitectureValidationInternal(RCTLogLevelInfo, type, context, extra);
+}
 
-  RCTLogInfo(@"%@", validationMessage(type, context, extra));
+void RCTNewArchitectureValidationPlaceholder(RCTNotAllowedValidation type, id context, NSString *extra)
+{
+#if RCT_ONLY_NEW_ARCHITECTURE
+  newArchitectureValidationInternal(RCTLogLevelInfo, type, context, extra);
+#endif
 }

package/React/Base/RCTConstants.h

@@ -23,10 +23,10 @@ RCT_EXTERN BOOL RCTGetDispatchW3CPointerEvents(void);
 RCT_EXTERN void RCTSetDispatchW3CPointerEvents(BOOL value);
 
 /*
- * Memory Pressure Unloading
+ * Validate RCTEventEmitter
  */
-RCT_EXTERN BOOL RCTGetDisableBridgeMemoryPressureUnload(void);
-RCT_EXTERN void RCTSetDisableBridgeMemoryPressureUnload(BOOL value);
+RCT_EXTERN BOOL RCTGetValidateCanSendEventInRCTEventEmitter(void);
+RCT_EXTERN void RCTSetValidateCanSendEventInRCTEventEmitter(BOOL value);
 
 /*
  * Memory Pressure Unloading Level

package/React/Base/RCTConstants.m

@@ -41,18 +41,18 @@ void RCTSetDispatchW3CPointerEvents(BOOL value)
 }
 
 /*
- * Memory Pressure Unloading
+ * Validate RCTEventEmitter. For experimentation only.
  */
-static BOOL RCTDisableBridgeMemoryPressureUnload = NO;
+static BOOL RCTValidateCanSendEventInRCTEventEmitter = NO;
 
-BOOL RCTGetDisableBridgeMemoryPressureUnload()
+BOOL RCTGetValidateCanSendEventInRCTEventEmitter()
 {
-  return RCTDisableBridgeMemoryPressureUnload;
+  return RCTValidateCanSendEventInRCTEventEmitter;
 }
 
-void RCTSetDisableBridgeMemoryPressureUnload(BOOL value)
+void RCTSetValidateCanSendEventInRCTEventEmitter(BOOL value)
 {
-  RCTDisableBridgeMemoryPressureUnload = value;
+  RCTValidateCanSendEventInRCTEventEmitter = value;
 }
 
 /*

package/React/Base/RCTDefines.h

@@ -157,7 +157,7 @@
  * Note: this is work in progress.
  */
 #ifdef REACT_NATIVE_FORCE_NEW_ARCHITECTURE
-#define RCT_NEW_ARCHITECTURE 1
+#define RCT_ONLY_NEW_ARCHITECTURE 1
 #else
-#define RCT_NEW_ARCHITECTURE 0
+#define RCT_ONLY_NEW_ARCHITECTURE 0
 #endif

package/React/Base/RCTEventDispatcherProtocol.h

@@ -102,6 +102,11 @@ typedef NS_ENUM(NSInteger, RCTTextEventType) {
                           key:(NSString *)key
                    eventCount:(NSInteger)eventCount;
 
+/**
+ * Notify Observers of event
+ */
+- (void)notifyObserversOfEvent:(id<RCTEvent>)event;
+
 /**
  * Send a pre-prepared event object.
  *

package/React/Base/RCTMultipartStreamReader.m

@@ -6,6 +6,7 @@
  */
 
 #import "RCTMultipartStreamReader.h"
+#import <QuartzCore/QuartzCore.h>
 
 #define CRLF @"\r\n"
 

package/React/Base/RCTUtils.h

@@ -186,4 +186,6 @@ RCT_EXTERN BOOL RCTValidateTypeOfViewCommandArgument(
     NSString const *commandName,
     NSString const *argPos);
 
+RCT_EXTERN BOOL RCTIsAppActive(void);
+
 NS_ASSUME_NONNULL_END

package/React/Base/RCTUtils.m

@@ -1067,3 +1067,8 @@ RCT_EXTERN BOOL RCTValidateTypeOfViewCommandArgument(
 
   return true;
 }
+
+BOOL RCTIsAppActive(void)
+{
+  return [RCTSharedApplication() applicationState] == UIApplicationStateActive;
+}

package/React/Base/RCTVersion.m

@@ -22,9 +22,9 @@ NSDictionary* RCTGetReactNativeVersion(void)
   dispatch_once(&onceToken, ^(void){
     __rnVersion = @{
                   RCTVersionMajor: @(0),
-                  RCTVersionMinor: @(69),
+                  RCTVersionMinor: @(70),
                   RCTVersionPatch: @(0),
-                  RCTVersionPrerelease: @"rc.6",
+                  RCTVersionPrerelease: @"rc.0",
                   };
   });
   return __rnVersion;

package/React/Base/Surface/RCTSurface.mm

@@ -64,7 +64,7 @@
                     moduleName:(NSString *)moduleName
              initialProperties:(NSDictionary *)initialProperties
 {
-  RCTErrorNewArchitectureValidation(RCTNotAllowedInAppWideFabric, @"RCTSurface", nil);
+  RCTErrorNewArchitectureValidation(RCTNotAllowedInFabricWithoutLegacy, @"RCTSurface", nil);
   RCTAssert(bridge.valid, @"Valid bridge is required to instantiate `RCTSurface`.");
 
   if (self = [super init]) {

package/React/CoreModules/RCTAlertManager.mm

@@ -32,6 +32,20 @@ RCT_ENUM_CONVERTER(
 
 @end
 
+@implementation RCTConvert (UIUserInterfaceStyle)
+
+RCT_ENUM_CONVERTER(
+    UIUserInterfaceStyle,
+    (@{
+      @"unspecified" : @(UIUserInterfaceStyleUnspecified),
+      @"light" : @(UIUserInterfaceStyleLight),
+      @"dark" : @(UIUserInterfaceStyleDark),
+    }),
+    UIUserInterfaceStyleUnspecified,
+    integerValue)
+
+@end
+
 @interface RCTAlertManager () <NativeAlertManagerSpec>
 
 @end
@@ -103,6 +117,15 @@ RCT_EXPORT_METHOD(alertWithArgs : (JS::NativeAlertManager::Args &)args callback
   RCTAlertController *alertController = [RCTAlertController alertControllerWithTitle:title
                                                                              message:nil
                                                                       preferredStyle:UIAlertControllerStyleAlert];
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+  if (@available(iOS 13.0, *)) {
+    UIUserInterfaceStyle userInterfaceStyle = [RCTConvert UIUserInterfaceStyle:args.userInterfaceStyle()];
+    alertController.overrideUserInterfaceStyle = userInterfaceStyle;
+  }
+#endif
+
   switch (type) {
     case RCTAlertViewStylePlainTextInput: {
       [alertController addTextFieldWithConfigurationHandler:^(UITextField *textField) {

package/React/CoreModules/RCTAppState.mm

@@ -103,7 +103,7 @@ RCT_EXPORT_MODULE()
 
 - (void)handleMemoryWarning
 {
-  if (self.bridge) {
+  if ([self canSendEvents_DEPRECATED]) {
     [self sendEventWithName:@"memoryWarning" body:nil];
   }
 }
@@ -122,7 +122,7 @@ RCT_EXPORT_MODULE()
 
   if (![newState isEqualToString:_lastKnownState]) {
     _lastKnownState = newState;
-    if (self.bridge) {
+    if ([self canSendEvents_DEPRECATED]) {
       [self sendEventWithName:@"appStateDidChange" body:@{@"app_state" : _lastKnownState}];
     }
   }

package/React/CoreModules/RCTDeviceInfo.mm

@@ -26,6 +26,7 @@ using namespace facebook::react;
 @implementation RCTDeviceInfo {
   UIInterfaceOrientation _currentInterfaceOrientation;
   NSDictionary *_currentInterfaceDimensions;
+  BOOL _isFullscreen;
 }
 
 @synthesize bridge = _bridge;
@@ -60,7 +61,7 @@ RCT_EXPORT_MODULE()
   _currentInterfaceDimensions = RCTExportedDimensions(_moduleRegistry, _bridge);
 
   [[NSNotificationCenter defaultCenter] addObserver:self
-                                           selector:@selector(interfaceFrameDidChange)
+                                           selector:@selector(interfaceOrientationDidChange)
                                                name:UIApplicationDidBecomeActiveNotification
                                              object:nil];
 
@@ -173,22 +174,36 @@ static NSDictionary *RCTExportedDimensions(RCTModuleRegistry *moduleRegistry, RC
 
 - (void)_interfaceOrientationDidChange
 {
-  UIInterfaceOrientation nextOrientation = [RCTSharedApplication() statusBarOrientation];
+  UIApplication *application = RCTSharedApplication();
+  UIInterfaceOrientation nextOrientation = [application statusBarOrientation];
+
+  BOOL isRunningInFullScreen =
+      CGRectEqualToRect(application.delegate.window.frame, application.delegate.window.screen.bounds);
+  // We are catching here two situations for multitasking view:
+  // a) The app is in Split View and the container gets resized -> !isRunningInFullScreen
+  // b) The app changes to/from fullscreen example: App runs in slide over mode and goes into fullscreen->
+  // isRunningInFullScreen != _isFullscreen The above two cases a || b can be shortened to !isRunningInFullScreen ||
+  // !_isFullscreen;
+  BOOL isResizingOrChangingToFullscreen = !isRunningInFullScreen || !_isFullscreen;
+  BOOL isOrientationChanging = (UIInterfaceOrientationIsPortrait(_currentInterfaceOrientation) &&
+                                !UIInterfaceOrientationIsPortrait(nextOrientation)) ||
+      (UIInterfaceOrientationIsLandscape(_currentInterfaceOrientation) &&
+       !UIInterfaceOrientationIsLandscape(nextOrientation));
 
   // Update when we go from portrait to landscape, or landscape to portrait
-  if ((UIInterfaceOrientationIsPortrait(_currentInterfaceOrientation) &&
-       !UIInterfaceOrientationIsPortrait(nextOrientation)) ||
-      (UIInterfaceOrientationIsLandscape(_currentInterfaceOrientation) &&
-       !UIInterfaceOrientationIsLandscape(nextOrientation))) {
+  // Also update when the fullscreen state changes (multitasking) and only when the app is in active state.
+  if ((isOrientationChanging || isResizingOrChangingToFullscreen) && RCTIsAppActive()) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     [[_moduleRegistry moduleForName:"EventDispatcher"]
         sendDeviceEventWithName:@"didUpdateDimensions"
                            body:RCTExportedDimensions(_moduleRegistry, _bridge)];
+    // We only want to track the current _currentInterfaceOrientation and _isFullscreen only
+    // when it happens and only when it is published.
+    _currentInterfaceOrientation = nextOrientation;
+    _isFullscreen = isRunningInFullScreen;
 #pragma clang diagnostic pop
   }
-
-  _currentInterfaceOrientation = nextOrientation;
 }
 
 - (void)interfaceFrameDidChange
@@ -203,15 +218,17 @@ static NSDictionary *RCTExportedDimensions(RCTModuleRegistry *moduleRegistry, RC
 {
   NSDictionary *nextInterfaceDimensions = RCTExportedDimensions(_moduleRegistry, _bridge);
 
-  if (!([nextInterfaceDimensions isEqual:_currentInterfaceDimensions])) {
+  // update and publish the even only when the app is in active state
+  if (!([nextInterfaceDimensions isEqual:_currentInterfaceDimensions]) && RCTIsAppActive()) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     [[_moduleRegistry moduleForName:"EventDispatcher"] sendDeviceEventWithName:@"didUpdateDimensions"
                                                                           body:nextInterfaceDimensions];
+    // We only want to track the current _currentInterfaceOrientation only
+    // when it happens and only when it is published.
+    _currentInterfaceDimensions = nextInterfaceDimensions;
 #pragma clang diagnostic pop
   }
-
-  _currentInterfaceDimensions = nextInterfaceDimensions;
 }
 
 - (std::shared_ptr<TurboModule>)getTurboModule:(const ObjCTurboModule::InitParams &)params

package/React/CoreModules/RCTEventDispatcher.mm

@@ -110,7 +110,7 @@ RCT_EXPORT_MODULE()
   [self sendEvent:event];
 }
 
-- (void)sendEvent:(id<RCTEvent>)event
+- (void)notifyObserversOfEvent:(id<RCTEvent>)event
 {
   [_observersLock lock];
 
@@ -119,6 +119,11 @@ RCT_EXPORT_MODULE()
   }
 
   [_observersLock unlock];
+}
+
+- (void)sendEvent:(id<RCTEvent>)event
+{
+  [self notifyObserversOfEvent:event];
 
   [_eventQueueLock lock];
 

package/React/CoreModules/RCTExceptionsManager.h

@@ -38,7 +38,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)reportFatalException:(nullable NSString *)message
                        stack:(nullable NSArray<NSDictionary *> *)stack
                  exceptionId:(double)exceptionId;
-- (void)reportEarlyJsException:(NSString *)errorMap;
+- (void)reportJsException:(NSString *)errorMap;
 
 @property (nonatomic, weak) id<RCTExceptionsManagerDelegate> delegate;