@office-iss/react-native-win32 0.0.0-canary.258 → 0.0.0-canary.260

package/src/private/{core/components → components}/useSyncOnScroll.js

@@ -9,8 +9,8 @@
  * @oncall react_native
  */
 
-import type {ScrollViewNativeProps} from '../../../../Libraries/Components/ScrollView/ScrollViewNativeComponentType';
-import type {HostComponent} from '../../../../Libraries/Renderer/shims/ReactNativeTypes';
+import type {ScrollViewNativeProps} from '../../../Libraries/Components/ScrollView/ScrollViewNativeComponentType';
+import type {HostComponent} from '../../../Libraries/Renderer/shims/ReactNativeTypes';
 
 import * as React from 'react';
 import {useImperativeHandle, useRef, useState} from 'react';

package/src/private/featureflags/ReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<522f11a571457cb932f451cf81bd384a>>
+ * @generated SignedSource<<fb7a3dcf7b3e5001e45f808fb4410376>>
  * @flow strict-local
  */
 
@@ -31,10 +31,14 @@ export type ReactNativeFeatureFlagsJsOnly = {
   animatedShouldUseSingleOp: Getter<boolean>,
   enableAccessToHostTreeInFabric: Getter<boolean>,
   isLayoutAnimationEnabled: Getter<boolean>,
+  shouldSkipStateUpdatesForLoopingAnimations: Getter<boolean>,
   shouldUseAnimatedObjectForTransform: Getter<boolean>,
-  shouldUseOptimizedText: Getter<boolean>,
+  shouldUseDebouncedEffectsForAnimated: Getter<boolean>,
   shouldUseRemoveClippedSubviewsAsDefaultOnIOS: Getter<boolean>,
   shouldUseSetNativePropsInFabric: Getter<boolean>,
+  shouldUseSetNativePropsInNativeAnimationsInFabric: Getter<boolean>,
+  usePassiveEffectsForAnimations: Getter<boolean>,
+  useRefsForTextInputState: Getter<boolean>,
 };
 
 export type ReactNativeFeatureFlagsJsOnlyOverrides = Partial<ReactNativeFeatureFlagsJsOnly>;
@@ -42,30 +46,50 @@ export type ReactNativeFeatureFlagsJsOnlyOverrides = Partial<ReactNativeFeatureF
 export type ReactNativeFeatureFlags = {
   ...ReactNativeFeatureFlagsJsOnly,
   commonTestFlag: Getter<boolean>,
-  allowCollapsableChildren: Getter<boolean>,
   allowRecursiveCommitsWithSynchronousMountOnAndroid: Getter<boolean>,
   batchRenderingUpdatesInEventLoop: Getter<boolean>,
+  changeOrderOfMountingInstructionsOnAndroid: Getter<boolean>,
+  completeReactInstanceCreationOnBgThreadOnAndroid: Getter<boolean>,
   destroyFabricSurfacesInReactInstanceManager: Getter<boolean>,
-  enableBackgroundExecutor: Getter<boolean>,
+  enableAlignItemsBaselineOnFabricIOS: Getter<boolean>,
+  enableAndroidMixBlendModeProp: Getter<boolean>,
+  enableBackgroundStyleApplicator: Getter<boolean>,
   enableCleanTextInputYogaNode: Getter<boolean>,
+  enableEagerRootViewAttachment: Getter<boolean>,
+  enableEventEmitterRetentionDuringGesturesOnAndroid: Getter<boolean>,
+  enableFabricLogs: Getter<boolean>,
+  enableFabricRendererExclusively: Getter<boolean>,
   enableGranularShadowTreeStateReconciliation: Getter<boolean>,
+  enableLongTaskAPI: Getter<boolean>,
   enableMicrotasks: Getter<boolean>,
+  enablePropsUpdateReconciliationAndroid: Getter<boolean>,
+  enableReportEventPaintTime: Getter<boolean>,
   enableSynchronousStateUpdates: Getter<boolean>,
   enableUIConsistency: Getter<boolean>,
+  enableViewRecycling: Getter<boolean>,
+  excludeYogaFromRawProps: Getter<boolean>,
+  fetchImagesInViewPreallocation: Getter<boolean>,
+  fixIncorrectScrollViewStateUpdateOnAndroid: Getter<boolean>,
   fixMappingOfEventPrioritiesBetweenFabricAndReact: Getter<boolean>,
-  fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak: Getter<boolean>,
+  fixMissedFabricStateUpdatesOnAndroid: Getter<boolean>,
   forceBatchingMountItemsOnAndroid: Getter<boolean>,
   fuseboxEnabledDebug: Getter<boolean>,
   fuseboxEnabledRelease: Getter<boolean>,
+  initEagerTurboModulesOnNativeModulesQueueAndroid: Getter<boolean>,
   lazyAnimationCallbacks: Getter<boolean>,
-  preventDoubleTextMeasure: Getter<boolean>,
+  loadVectorDrawablesOnImages: Getter<boolean>,
   setAndroidLayoutDirection: Getter<boolean>,
+  traceTurboModulePromiseRejectionsOnAndroid: Getter<boolean>,
+  useFabricInterop: Getter<boolean>,
   useImmediateExecutorInAndroidBridgeless: Getter<boolean>,
   useModernRuntimeScheduler: Getter<boolean>,
   useNativeViewConfigsInBridgelessMode: Getter<boolean>,
+  useNewReactImageViewBackgroundDrawing: Getter<boolean>,
+  useOptimisedViewPreallocationOnAndroid: Getter<boolean>,
   useRuntimeShadowNodeReferenceUpdate: Getter<boolean>,
   useRuntimeShadowNodeReferenceUpdateOnLayout: Getter<boolean>,
   useStateAlignmentMechanism: Getter<boolean>,
+  useTurboModuleInterop: Getter<boolean>,
 }
 
 /**
@@ -93,15 +117,20 @@ export const enableAccessToHostTreeInFabric: Getter<boolean> = createJavaScriptF
  */
 export const isLayoutAnimationEnabled: Getter<boolean> = createJavaScriptFlagGetter('isLayoutAnimationEnabled', true);
 
+/**
+ * If the animation is within Animated.loop, we do not send state updates to React.
+ */
+export const shouldSkipStateUpdatesForLoopingAnimations: Getter<boolean> = createJavaScriptFlagGetter('shouldSkipStateUpdatesForLoopingAnimations', false);
+
 /**
  * Enables use of AnimatedObject for animating transform values.
  */
 export const shouldUseAnimatedObjectForTransform: Getter<boolean> = createJavaScriptFlagGetter('shouldUseAnimatedObjectForTransform', false);
 
 /**
- * Use optimized version of <Text /> component.
+ * Use new `useDebouncedEffects` hook for manging animated props lifecycle.
  */
-export const shouldUseOptimizedText: Getter<boolean> = createJavaScriptFlagGetter('shouldUseOptimizedText', false);
+export const shouldUseDebouncedEffectsForAnimated: Getter<boolean> = createJavaScriptFlagGetter('shouldUseDebouncedEffectsForAnimated', false);
 
 /**
  * removeClippedSubviews prop will be used as the default in FlatList on iOS to match Android
@@ -114,13 +143,24 @@ export const shouldUseRemoveClippedSubviewsAsDefaultOnIOS: Getter<boolean> = cre
 export const shouldUseSetNativePropsInFabric: Getter<boolean> = createJavaScriptFlagGetter('shouldUseSetNativePropsInFabric', true);
 
 /**
- * Common flag for testing. Do NOT modify.
+ * Enables use of setNativeProps in Native driven animations in Fabric.
  */
-export const commonTestFlag: Getter<boolean> = createNativeFlagGetter('commonTestFlag', false);
+export const shouldUseSetNativePropsInNativeAnimationsInFabric: Getter<boolean> = createJavaScriptFlagGetter('shouldUseSetNativePropsInNativeAnimationsInFabric', false);
+
+/**
+ * Enable a variant of useAnimatedPropsLifecycle hook that constructs the animation graph in passive effect instead of layout effect
+ */
+export const usePassiveEffectsForAnimations: Getter<boolean> = createJavaScriptFlagGetter('usePassiveEffectsForAnimations', false);
+
 /**
- * Enables the differentiator to understand the "collapsableChildren" prop
+ * Enable a variant of TextInput that moves some state to refs to avoid unnecessary re-renders
  */
-export const allowCollapsableChildren: Getter<boolean> = createNativeFlagGetter('allowCollapsableChildren', true);
+export const useRefsForTextInputState: Getter<boolean> = createJavaScriptFlagGetter('useRefsForTextInputState', false);
+
+/**
+ * Common flag for testing. Do NOT modify.
+ */
+export const commonTestFlag: Getter<boolean> = createNativeFlagGetter('commonTestFlag', false);
 /**
  * Adds support for recursively processing commits that mount synchronously (Android only).
  */
@@ -129,26 +169,70 @@ export const allowRecursiveCommitsWithSynchronousMountOnAndroid: Getter<boolean>
  * When enabled, the RuntimeScheduler processing the event loop will batch all rendering updates and dispatch them together at the end of each iteration of the loop.
  */
 export const batchRenderingUpdatesInEventLoop: Getter<boolean> = createNativeFlagGetter('batchRenderingUpdatesInEventLoop', false);
+/**
+ * When enabled, insert of views on Android will be moved from the beginning of the IntBufferBatchMountItem to be after layout updates.
+ */
+export const changeOrderOfMountingInstructionsOnAndroid: Getter<boolean> = createNativeFlagGetter('changeOrderOfMountingInstructionsOnAndroid', false);
+/**
+ * Do not wait for a main-thread dispatch to complete init to start executing work on the JS thread on Android
+ */
+export const completeReactInstanceCreationOnBgThreadOnAndroid: Getter<boolean> = createNativeFlagGetter('completeReactInstanceCreationOnBgThreadOnAndroid', false);
 /**
  * When enabled, ReactInstanceManager will clean up Fabric surfaces on destroy().
  */
 export const destroyFabricSurfacesInReactInstanceManager: Getter<boolean> = createNativeFlagGetter('destroyFabricSurfacesInReactInstanceManager', false);
 /**
- * Enables the use of a background executor to compute layout and commit updates on Fabric (this system is deprecated and should not be used).
+ * Kill-switch to turn off support for aling-items:baseline on Fabric iOS.
+ */
+export const enableAlignItemsBaselineOnFabricIOS: Getter<boolean> = createNativeFlagGetter('enableAlignItemsBaselineOnFabricIOS', true);
+/**
+ * Enables mix-blend-mode prop on Android.
+ */
+export const enableAndroidMixBlendModeProp: Getter<boolean> = createNativeFlagGetter('enableAndroidMixBlendModeProp', false);
+/**
+ * Use BackgroundStyleApplicator in place of other background/border drawing code
  */
-export const enableBackgroundExecutor: Getter<boolean> = createNativeFlagGetter('enableBackgroundExecutor', false);
+export const enableBackgroundStyleApplicator: Getter<boolean> = createNativeFlagGetter('enableBackgroundStyleApplicator', true);
 /**
  * Clean yoga node when <TextInput /> does not change.
  */
 export const enableCleanTextInputYogaNode: Getter<boolean> = createNativeFlagGetter('enableCleanTextInputYogaNode', false);
+/**
+ * Feature flag to configure eager attachment of the root view/initialisation of the JS code.
+ */
+export const enableEagerRootViewAttachment: Getter<boolean> = createNativeFlagGetter('enableEagerRootViewAttachment', false);
+/**
+ * Enables the retention of EventEmitterWrapper on Android till the touch gesture is over to fix a bug on pressable (#44610)
+ */
+export const enableEventEmitterRetentionDuringGesturesOnAndroid: Getter<boolean> = createNativeFlagGetter('enableEventEmitterRetentionDuringGesturesOnAndroid', false);
+/**
+ * This feature flag enables logs for Fabric.
+ */
+export const enableFabricLogs: Getter<boolean> = createNativeFlagGetter('enableFabricLogs', false);
+/**
+ * When the app is completely migrated to Fabric, set this flag to true to disable parts of Paper infrastructure that are not needed anymore but consume memory and CPU. Specifically, UIViewOperationQueue and EventDispatcherImpl will no longer work as they will not subscribe to ReactChoreographer for updates.
+ */
+export const enableFabricRendererExclusively: Getter<boolean> = createNativeFlagGetter('enableFabricRendererExclusively', false);
 /**
  * When enabled, the renderer would only fail commits when they propagate state and the last commit that updated state changed before committing.
  */
 export const enableGranularShadowTreeStateReconciliation: Getter<boolean> = createNativeFlagGetter('enableGranularShadowTreeStateReconciliation', false);
+/**
+ * Enables the reporting of long tasks through `PerformanceObserver`. Only works if the event loop is enabled.
+ */
+export const enableLongTaskAPI: Getter<boolean> = createNativeFlagGetter('enableLongTaskAPI', false);
 /**
  * Enables the use of microtasks in Hermes (scheduling) and RuntimeScheduler (execution).
  */
 export const enableMicrotasks: Getter<boolean> = createNativeFlagGetter('enableMicrotasks', false);
+/**
+ * When enabled, Android will receive prop updates based on the differences between the last rendered shadow node and the last committed shadow node.
+ */
+export const enablePropsUpdateReconciliationAndroid: Getter<boolean> = createNativeFlagGetter('enablePropsUpdateReconciliationAndroid', false);
+/**
+ * Report paint time inside the Event Timing API implementation (PerformanceObserver).
+ */
+export const enableReportEventPaintTime: Getter<boolean> = createNativeFlagGetter('enableReportEventPaintTime', false);
 /**
  * Dispatches state updates synchronously in Fabric (e.g.: updates the scroll position in the shadow tree synchronously from the main thread).
  */
@@ -157,14 +241,30 @@ export const enableSynchronousStateUpdates: Getter<boolean> = createNativeFlagGe
  * Ensures that JavaScript always has a consistent view of the state of the UI (e.g.: commits done in other threads are not immediately propagated to JS during its execution).
  */
 export const enableUIConsistency: Getter<boolean> = createNativeFlagGetter('enableUIConsistency', false);
+/**
+ * Enables View Recycling. When enabled, individual ViewManagers must still opt-in.
+ */
+export const enableViewRecycling: Getter<boolean> = createNativeFlagGetter('enableViewRecycling', false);
+/**
+ * When enabled, rawProps in Props will not include Yoga specific props.
+ */
+export const excludeYogaFromRawProps: Getter<boolean> = createNativeFlagGetter('excludeYogaFromRawProps', false);
+/**
+ * Start image fetching during view preallocation instead of waiting for layout pass
+ */
+export const fetchImagesInViewPreallocation: Getter<boolean> = createNativeFlagGetter('fetchImagesInViewPreallocation', false);
+/**
+ * When doing a smooth scroll animation, it stops setting the state with the final scroll position in Fabric before the animation starts.
+ */
+export const fixIncorrectScrollViewStateUpdateOnAndroid: Getter<boolean> = createNativeFlagGetter('fixIncorrectScrollViewStateUpdateOnAndroid', false);
 /**
  * Uses the default event priority instead of the discreet event priority by default when dispatching events from Fabric to React.
  */
 export const fixMappingOfEventPrioritiesBetweenFabricAndReact: Getter<boolean> = createNativeFlagGetter('fixMappingOfEventPrioritiesBetweenFabricAndReact', false);
 /**
- * Fixes a leak in SurfaceMountingManager.mRemoveDeleteTreeUIFrameCallback
+ * Enables a fix to prevent the possibility of state updates in Fabric being missed due to race conditions with previous state updates.
  */
-export const fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak: Getter<boolean> = createNativeFlagGetter('fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak', false);
+export const fixMissedFabricStateUpdatesOnAndroid: Getter<boolean> = createNativeFlagGetter('fixMissedFabricStateUpdatesOnAndroid', false);
 /**
  * Forces the mounting layer on Android to always batch mount items instead of dispatching them immediately. This might fix some crashes related to synchronous state updates, where some views dispatch state updates during mount.
  */
@@ -172,23 +272,35 @@ export const forceBatchingMountItemsOnAndroid: Getter<boolean> = createNativeFla
 /**
  * Flag determining if the React Native DevTools (Fusebox) CDP backend should be enabled in debug builds. This flag is global and should not be changed across React Host lifetimes.
  */
-export const fuseboxEnabledDebug: Getter<boolean> = createNativeFlagGetter('fuseboxEnabledDebug', false);
+export const fuseboxEnabledDebug: Getter<boolean> = createNativeFlagGetter('fuseboxEnabledDebug', true);
 /**
  * Flag determining if the React Native DevTools (Fusebox) CDP backend should be enabled in release builds. This flag is global and should not be changed across React Host lifetimes.
  */
 export const fuseboxEnabledRelease: Getter<boolean> = createNativeFlagGetter('fuseboxEnabledRelease', false);
+/**
+ * Construct modules that requires eager init on the dedicate native modules thread
+ */
+export const initEagerTurboModulesOnNativeModulesQueueAndroid: Getter<boolean> = createNativeFlagGetter('initEagerTurboModulesOnNativeModulesQueueAndroid', false);
 /**
  * Only enqueue Choreographer calls if there is an ongoing animation, instead of enqueueing every frame.
  */
 export const lazyAnimationCallbacks: Getter<boolean> = createNativeFlagGetter('lazyAnimationCallbacks', false);
 /**
- * When enabled, ParagraphShadowNode will no longer call measure twice.
+ * Adds support for loading vector drawable assets in the Image component (only on Android)
  */
-export const preventDoubleTextMeasure: Getter<boolean> = createNativeFlagGetter('preventDoubleTextMeasure', true);
+export const loadVectorDrawablesOnImages: Getter<boolean> = createNativeFlagGetter('loadVectorDrawablesOnImages', false);
 /**
  * Propagate layout direction to Android views.
  */
 export const setAndroidLayoutDirection: Getter<boolean> = createNativeFlagGetter('setAndroidLayoutDirection', false);
+/**
+ * Enables storing js caller stack when creating promise in native module. This is useful in case of Promise rejection and tracing the cause.
+ */
+export const traceTurboModulePromiseRejectionsOnAndroid: Getter<boolean> = createNativeFlagGetter('traceTurboModulePromiseRejectionsOnAndroid', false);
+/**
+ * Should this application enable the Fabric Interop Layer for Android? If yes, the application will behave so that it can accept non-Fabric components and render them on Fabric. This toggle is controlling extra logic such as custom event dispatching that are needed for the Fabric Interop Layer to work correctly.
+ */
+export const useFabricInterop: Getter<boolean> = createNativeFlagGetter('useFabricInterop', false);
 /**
  * Invoke callbacks immediately on the ReactInstance rather than going through a background thread for synchronization
  */
@@ -201,6 +313,14 @@ export const useModernRuntimeScheduler: Getter<boolean> = createNativeFlagGetter
  * When enabled, the native view configs are used in bridgeless mode.
  */
 export const useNativeViewConfigsInBridgelessMode: Getter<boolean> = createNativeFlagGetter('useNativeViewConfigsInBridgelessMode', false);
+/**
+ * Use shared background drawing code for ReactImageView instead of using Fresco to manipulate the bitmap
+ */
+export const useNewReactImageViewBackgroundDrawing: Getter<boolean> = createNativeFlagGetter('useNewReactImageViewBackgroundDrawing', false);
+/**
+ * Moves more of the work in view preallocation to the main thread to free up JS thread.
+ */
+export const useOptimisedViewPreallocationOnAndroid: Getter<boolean> = createNativeFlagGetter('useOptimisedViewPreallocationOnAndroid', false);
 /**
  * When enabled, cloning shadow nodes within react native will update the reference held by the current JS fiber tree.
  */
@@ -213,6 +333,10 @@ export const useRuntimeShadowNodeReferenceUpdateOnLayout: Getter<boolean> = crea
  * When enabled, it uses optimised state reconciliation algorithm.
  */
 export const useStateAlignmentMechanism: Getter<boolean> = createNativeFlagGetter('useStateAlignmentMechanism', false);
+/**
+ * In Bridgeless mode, should legacy NativeModules use the TurboModule system?
+ */
+export const useTurboModuleInterop: Getter<boolean> = createNativeFlagGetter('useTurboModuleInterop', false);
 
 /**
  * Overrides the feature flags with the provided methods.

package/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<6715ba4954b31464c591597c53a2a0de>>
+ * @generated SignedSource<<9728234e0662758c72ba79b3cffbd4e5>>
  * @flow strict-local
  */
 
@@ -24,30 +24,50 @@ import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboMod
 
 export interface Spec extends TurboModule {
   +commonTestFlag?: () => boolean;
-  +allowCollapsableChildren?: () => boolean;
   +allowRecursiveCommitsWithSynchronousMountOnAndroid?: () => boolean;
   +batchRenderingUpdatesInEventLoop?: () => boolean;
+  +changeOrderOfMountingInstructionsOnAndroid?: () => boolean;
+  +completeReactInstanceCreationOnBgThreadOnAndroid?: () => boolean;
   +destroyFabricSurfacesInReactInstanceManager?: () => boolean;
-  +enableBackgroundExecutor?: () => boolean;
+  +enableAlignItemsBaselineOnFabricIOS?: () => boolean;
+  +enableAndroidMixBlendModeProp?: () => boolean;
+  +enableBackgroundStyleApplicator?: () => boolean;
   +enableCleanTextInputYogaNode?: () => boolean;
+  +enableEagerRootViewAttachment?: () => boolean;
+  +enableEventEmitterRetentionDuringGesturesOnAndroid?: () => boolean;
+  +enableFabricLogs?: () => boolean;
+  +enableFabricRendererExclusively?: () => boolean;
   +enableGranularShadowTreeStateReconciliation?: () => boolean;
+  +enableLongTaskAPI?: () => boolean;
   +enableMicrotasks?: () => boolean;
+  +enablePropsUpdateReconciliationAndroid?: () => boolean;
+  +enableReportEventPaintTime?: () => boolean;
   +enableSynchronousStateUpdates?: () => boolean;
   +enableUIConsistency?: () => boolean;
+  +enableViewRecycling?: () => boolean;
+  +excludeYogaFromRawProps?: () => boolean;
+  +fetchImagesInViewPreallocation?: () => boolean;
+  +fixIncorrectScrollViewStateUpdateOnAndroid?: () => boolean;
   +fixMappingOfEventPrioritiesBetweenFabricAndReact?: () => boolean;
-  +fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak?: () => boolean;
+  +fixMissedFabricStateUpdatesOnAndroid?: () => boolean;
   +forceBatchingMountItemsOnAndroid?: () => boolean;
   +fuseboxEnabledDebug?: () => boolean;
   +fuseboxEnabledRelease?: () => boolean;
+  +initEagerTurboModulesOnNativeModulesQueueAndroid?: () => boolean;
   +lazyAnimationCallbacks?: () => boolean;
-  +preventDoubleTextMeasure?: () => boolean;
+  +loadVectorDrawablesOnImages?: () => boolean;
   +setAndroidLayoutDirection?: () => boolean;
+  +traceTurboModulePromiseRejectionsOnAndroid?: () => boolean;
+  +useFabricInterop?: () => boolean;
   +useImmediateExecutorInAndroidBridgeless?: () => boolean;
   +useModernRuntimeScheduler?: () => boolean;
   +useNativeViewConfigsInBridgelessMode?: () => boolean;
+  +useNewReactImageViewBackgroundDrawing?: () => boolean;
+  +useOptimisedViewPreallocationOnAndroid?: () => boolean;
   +useRuntimeShadowNodeReferenceUpdate?: () => boolean;
   +useRuntimeShadowNodeReferenceUpdateOnLayout?: () => boolean;
   +useStateAlignmentMechanism?: () => boolean;
+  +useTurboModuleInterop?: () => boolean;
 }
 
 const NativeReactNativeFeatureFlags: ?Spec = TurboModuleRegistry.get<Spec>(

package/src/private/hooks/DebouncedEffectImplementation.js

@@ -0,0 +1,148 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+'use strict';
+
+// $FlowFixMe[untyped-type-import] used as an opaque type
+import type {Task} from 'scheduler';
+// $FlowFixMe[untyped-type-import] used as an opaque type
+import typeof Scheduler from 'scheduler';
+
+import {useCallback, useEffect, useRef} from 'react';
+
+type EffectStatus =
+  // The effect is scheduled but has not yet run. The cleanup function is from
+  // the last execution, if there was one. If the effect gets rescheduled, the
+  // cleanup function must be propagated so that it can run before the updated
+  // effect
+  | {
+      kind: 'scheduled',
+      // $FlowFixMe[value-as-type] Task is opaque
+      task: Task,
+      previousCleanup: null | (() => void),
+    }
+  // The effect has been executed and returned a cleanup function. If it ran
+  // but didn't return a cleanup function, the effect status is set to null.
+  | {
+      cleanup: () => void,
+      kind: 'executed',
+    };
+
+/**
+ * Similar to `useEffect`, this hook schedules a passive effect (@param fn) to
+ * run on mount and whenever the dependency array (@param deps) changes.
+ * However, unlike `useEffect` the effect is debounced so that it runs after
+ * a delay (idle priority callback), reseting if another render occurs. Another
+ * render can occur for example when a layout effect runs and sets state.
+ * Updates triggered in layout effects cause the next render to flush
+ * synchronously and will by default run passive effects first before the
+ * re-render (to flush effects with the original state), and then again after
+ * the re-render (to flush effects with the updated state).
+ *
+ * Instead, this hook will run the effect once per batched render, after it has
+ * committed/painted. The effect is scheduled at idle priority, and if another
+ * render occurs in the meantime it reschedules the effect. Thus the effect
+ * will only run when the component stops re-rendering. When the effect does
+ * run, it is guaranteed to be the latest version of the effect.
+ *
+ * @see https://react.dev/reference/react/useEffect for more on normal passive
+ * effect behavior.
+ */
+export default function useDebouncedEffectImplementation(
+  fn: () => void | (() => void),
+  deps?: ?$ReadOnlyArray<mixed>,
+  // $FlowFixMe[value-as-type] used as an opaque type
+  scheduler: Scheduler,
+): void {
+  const statusRef = useRef<null | EffectStatus>(null);
+
+  const scheduleTask = useCallback(
+    (
+      effectFn: null | (() => void | (() => void)),
+      previousCleanup: null | (() => void),
+    ): void => {
+      const status = statusRef.current;
+      if (status != null && status.kind === 'scheduled') {
+        scheduler.unstable_cancelCallback(status.task);
+      }
+      if (effectFn == null && previousCleanup == null) {
+        statusRef.current = null;
+        return;
+      }
+      const task = scheduler.unstable_scheduleCallback(
+        scheduler.unstable_IdlePriority,
+        () => {
+          if (previousCleanup != null) {
+            previousCleanup();
+          }
+          let cleanup = null;
+          if (effectFn != null) {
+            cleanup = effectFn() ?? null;
+          }
+          if (cleanup == null) {
+            statusRef.current = null;
+          } else {
+            statusRef.current = {
+              kind: 'executed',
+              cleanup,
+            };
+          }
+        },
+      );
+      statusRef.current = {
+        kind: 'scheduled',
+        task,
+        previousCleanup,
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+
+  useEffect(() => {
+    const statusInEffect = statusRef.current;
+    if (statusInEffect == null) {
+      scheduleTask(fn, null);
+    } else if (statusInEffect.kind === 'scheduled') {
+      // Need to cancel & reschedule, maintaining the same cleanup function.
+      scheduleTask(fn, statusInEffect.previousCleanup);
+    } else {
+      // Already executed, we need to schedule a new task and call the cleanup
+      // function from the last execution
+      scheduleTask(fn, statusInEffect.cleanup);
+    }
+
+    return () => {
+      // Rather than immediately run cleanup, we schedule the cleanup task.
+      // If the effect is about to update, then we'll cancel this task and
+      // reschedule with both the cleanup and the new effect function (see above)
+      const statusAtCleanup = statusRef.current;
+      if (statusAtCleanup == null) {
+        // nothing to do, nothing is scheduled and if the task ran already, it
+        // didn't have a cleanup function
+        return;
+      } else if (statusAtCleanup.kind === 'scheduled') {
+        // The task is scheduled but has not yet run. Reschedule just the
+        // cleanup function (the effect function portion may be
+        // overridden momentarily if the effect is about to update, but that's
+        // okay).
+        // Note that if cleanup is null, this will just clear the pending task
+        // and not schedule a new one
+        scheduleTask(null, statusAtCleanup.previousCleanup);
+      } else {
+        // If kind === executed, then we know there is a cleanup function that
+        // still needs to run so schedule it
+        scheduleTask(null, statusAtCleanup.cleanup);
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, deps);
+}

package/src/private/hooks/useDebouncedEffect.js

@@ -0,0 +1,23 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+'use strict';
+
+import useDebouncedEffectImplementation from './DebouncedEffectImplementation';
+// $FlowFixMe[untyped-import] used as an opaque type
+import Scheduler from 'scheduler';
+
+export default function useDebouncedEffect(
+  fn: () => void | (() => void),
+  deps?: ?$ReadOnlyArray<mixed>,
+): void {
+  return useDebouncedEffectImplementation(fn, deps, Scheduler);
+}

package/{Libraries/Core → src/private/renderer/errorhandling}/ErrorHandlers.js

@@ -8,11 +8,12 @@
  * @flow strict
  */
 
-'use strict';
+import type {ExtendedError} from '../../../../Libraries/Core/ExtendedError';
 
-import type {ExtendedError} from './ExtendedError';
-
-import {SyntheticError, handleException} from './ExceptionsManager';
+import {
+  SyntheticError,
+  handleException,
+} from '../../../../Libraries/Core/ExceptionsManager';
 
 type ErrorInfo = {
   +componentStack?: ?string,
@@ -28,14 +29,17 @@ export function onUncaughtError(errorValue: mixed, errorInfo: ErrorInfo): void {
   if (errorValue instanceof Error) {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (errorValue: ExtendedError);
   } else if (typeof errorValue === 'string') {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError(errorValue): ExtendedError);
   } else {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError('Unspecified error'): ExtendedError);
   }
   try {
@@ -58,14 +62,17 @@ export function onCaughtError(errorValue: mixed, errorInfo: ErrorInfo): void {
   if (errorValue instanceof Error) {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (errorValue: ExtendedError);
   } else if (typeof errorValue === 'string') {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError(errorValue): ExtendedError);
   } else {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError('Unspecified error'): ExtendedError);
   }
   try {
@@ -91,14 +98,17 @@ export function onRecoverableError(
   if (errorValue instanceof Error) {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (errorValue: ExtendedError);
   } else if (typeof errorValue === 'string') {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError(errorValue): ExtendedError);
   } else {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
+    // $FlowFixMe[incompatible-cast]
     error = (new SyntheticError('Unspecified error'): ExtendedError);
   }
   try {

package/src/private/setup/setUpDOM.js

@@ -0,0 +1,28 @@
+/**
+ * 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
+ */
+
+import DOMRect from '../webapis/dom/geometry/DOMRect';
+import DOMRectReadOnly from '../webapis/dom/geometry/DOMRectReadOnly';
+
+let initialized = false;
+
+export default function setUpDOM() {
+  if (initialized) {
+    return;
+  }
+
+  initialized = true;
+
+  // $FlowExpectedError[cannot-write] The global isn't writable anywhere but here, where we define it
+  global.DOMRect = DOMRect;
+
+  // $FlowExpectedError[cannot-write] The global isn't writable anywhere but here, where we define it
+  global.DOMRectReadOnly = DOMRectReadOnly;
+}