react-native-windows 0.81.1 → 0.82.0-preview.1

package/src/private/featureflags/ReactNativeFeatureFlagsBase.js

@@ -18,12 +18,16 @@ import NativeReactNativeFeatureFlags from './specs/NativeReactNativeFeatureFlags
 const accessedFeatureFlags: Set<string> = new Set();
 let overrides: ?ReactNativeFeatureFlagsJsOnlyOverrides;
 
+// This is a list of functions to clear the cached value for each feature flag
+// getter. This is only used in development.
+const clearCachedValuesFns: Array<() => void> = [];
+
 export type Getter<T> = () => T;
 
-// This defines the types for the overrides object, whose methods also receive
-// the default value as a parameter.
+// This defines the types for the overrides object, whose methods can return
+// null or undefined to fallback to the default value.
 export type OverridesFor<T> = Partial<{
-  [key in keyof T]: (ReturnType<T[key]>) => ReturnType<T[key]>,
+  [key in keyof T]: Getter<?ReturnType<T[key]>>,
 }>;
 
 function createGetter<T: boolean | number | string>(
@@ -33,6 +37,12 @@ function createGetter<T: boolean | number | string>(
 ): Getter<T> {
   let cachedValue: ?T;
 
+  if (__DEV__) {
+    clearCachedValuesFns.push(() => {
+      cachedValue = undefined;
+    });
+  }
+
   return () => {
     if (cachedValue == null) {
       cachedValue = customValueGetter() ?? defaultValue;
@@ -51,7 +61,7 @@ export function createJavaScriptFlagGetter<
     configName,
     () => {
       accessedFeatureFlags.add(configName);
-      return overrides?.[configName]?.(defaultValue);
+      return overrides?.[configName]?.();
     },
     defaultValue,
   );
@@ -118,3 +128,12 @@ function maybeLogUnavailableNativeModuleError(configName: string): void {
     );
   }
 }
+
+export function dangerouslyResetForTesting(): void {
+  if (__DEV__) {
+    overrides = null;
+    accessedFeatureFlags.clear();
+    reportedConfigNames.clear();
+    clearCachedValuesFns.forEach(fn => fn());
+  }
+}

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<<8b4f1275a16d5b83f5594da1eb89c6c1>>
+ * @generated SignedSource<<da22f4c43e3bdcd999e3dd1dd5896c63>>
  * @flow strict
  * @noformat
  */
@@ -26,11 +26,12 @@ import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboMod
 export interface Spec extends TurboModule {
   +commonTestFlag?: () => boolean;
   +commonTestFlagWithoutNativeImplementation?: () => boolean;
-  +animatedShouldSignalBatch?: () => boolean;
+  +cdpInteractionMetricsEnabled?: () => boolean;
   +cxxNativeAnimatedEnabled?: () => boolean;
   +cxxNativeAnimatedRemoveJsSync?: () => boolean;
-  +disableMainQueueSyncDispatchIOS?: () => boolean;
+  +disableFabricCommitInCXXAnimated?: () => boolean;
   +disableMountItemReorderingAndroid?: () => boolean;
+  +disableOldAndroidAttachmentMetricsWorkarounds?: () => boolean;
   +disableTextLayoutManagerCacheAndroid?: () => boolean;
   +enableAccessibilityOrder?: () => boolean;
   +enableAccumulatedUpdatesInRawPropsAndroid?: () => boolean;
@@ -40,18 +41,19 @@ export interface Spec extends TurboModule {
   +enableCustomFocusSearchOnClippedElementsAndroid?: () => boolean;
   +enableDestroyShadowTreeRevisionAsync?: () => boolean;
   +enableDoubleMeasurementFixAndroid?: () => boolean;
+  +enableEagerMainQueueModulesOnIOS?: () => boolean;
   +enableEagerRootViewAttachment?: () => boolean;
   +enableFabricLogs?: () => boolean;
   +enableFabricRenderer?: () => boolean;
-  +enableFixForParentTagDuringReparenting?: () => boolean;
   +enableFontScaleChangesUpdatingLayout?: () => boolean;
   +enableIOSTextBaselineOffsetPerLine?: () => boolean;
   +enableIOSViewClipToPaddingBox?: () => boolean;
+  +enableImagePrefetchingAndroid?: () => boolean;
+  +enableImmediateUpdateModeForContentOffsetChanges?: () => boolean;
   +enableInteropViewManagerClassLookUpOptimizationIOS?: () => boolean;
   +enableLayoutAnimationsOnAndroid?: () => boolean;
   +enableLayoutAnimationsOnIOS?: () => boolean;
   +enableMainQueueCoordinatorOnIOS?: () => boolean;
-  +enableMainQueueModulesOnIOS?: () => boolean;
   +enableModuleArgumentNSNullConversionIOS?: () => boolean;
   +enableNativeCSSParsing?: () => boolean;
   +enableNetworkEventReporting?: () => boolean;
@@ -59,9 +61,9 @@ export interface Spec extends TurboModule {
   +enablePreparedTextLayout?: () => boolean;
   +enablePropsUpdateReconciliationAndroid?: () => boolean;
   +enableResourceTimingAPI?: () => boolean;
-  +enableSynchronousStateUpdates?: () => boolean;
   +enableViewCulling?: () => boolean;
   +enableViewRecycling?: () => boolean;
+  +enableViewRecyclingForScrollView?: () => boolean;
   +enableViewRecyclingForText?: () => boolean;
   +enableViewRecyclingForView?: () => boolean;
   +enableVirtualViewDebugFeatures?: () => boolean;
@@ -71,8 +73,13 @@ export interface Spec extends TurboModule {
   +fuseboxEnabledRelease?: () => boolean;
   +fuseboxNetworkInspectionEnabled?: () => boolean;
   +hideOffscreenVirtualViewsOnIOS?: () => boolean;
+  +perfMonitorV2Enabled?: () => boolean;
   +preparedTextCacheSize?: () => number;
   +preventShadowTreeCommitExhaustion?: () => boolean;
+  +releaseImageDataWhenConsumed?: () => boolean;
+  +shouldPressibilityUseW3CPointerEventsForHover?: () => boolean;
+  +skipActivityIdentityAssertionOnHostPause?: () => boolean;
+  +sweepActiveTouchOnChildNativeGesturesAndroid?: () => boolean;
   +traceTurboModulePromiseRejectionsOnAndroid?: () => boolean;
   +updateRuntimeShadowNodeReferencesOnCommit?: () => boolean;
   +useAlwaysAvailableJSErrorHandling?: () => boolean;
@@ -85,6 +92,7 @@ export interface Spec extends TurboModule {
   +useShadowNodeStateOnClone?: () => boolean;
   +useTurboModuleInterop?: () => boolean;
   +useTurboModules?: () => boolean;
+  +virtualViewHysteresisRatio?: () => number;
   +virtualViewPrerenderRatio?: () => number;
 }
 

package/src/private/renderer/errorhandling/ErrorHandlers.js

@@ -32,17 +32,17 @@ function getExtendedError(
   if (errorValue instanceof Error) {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
-    // $FlowFixMe[incompatible-cast]
+    // $FlowFixMe[incompatible-type]
     error = (errorValue: ExtendedError);
   } else if (typeof errorValue === 'string') {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
-    // $FlowFixMe[incompatible-cast]
+    // $FlowFixMe[incompatible-type]
     error = (new SyntheticError(errorValue): ExtendedError);
   } else {
     /* $FlowFixMe[class-object-subtyping] added when improving typing for
      * this parameters */
-    // $FlowFixMe[incompatible-cast]
+    // $FlowFixMe[incompatible-type]
     error = (new SyntheticError('Unspecified error'): ExtendedError);
   }
   try {

package/src/private/specs_DEPRECATED/components/SwitchNativeComponent.js

@@ -58,5 +58,4 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
 export default (codegenNativeComponent<SwitchNativeProps>('Switch', {
   paperComponentName: 'RCTSwitch',
   excludedPlatforms: ['android'],
-  //#Windows interfaceOnly: true,
 }): ComponentType);

package/src/private/types/HostInstance.js

@@ -8,6 +8,9 @@
  * @format
  */
 
+// $FlowExpectedError[nonstrict-import] Making this module `strict-local` would require too many modules to revert back to `strict-local` as well.
+import type ReactNativeElement from '../webapis/dom/nodes/ReactNativeElement';
+
 export type MeasureOnSuccessCallback = (
   x: number,
   y: number,
@@ -105,7 +108,7 @@ export interface LegacyHostInstanceMethods {
   setNativeProps(nativeProps: {...}): void;
 }
 
-export type HostInstance = LegacyHostInstanceMethods;
+export type HostInstance = ReactNativeElement;
 
 /** @deprecated Use HostInstance instead */
 export type NativeMethods = LegacyHostInstanceMethods;

package/src/private/webapis/dom/nodes/ReactNativeDocument.js

@@ -14,9 +14,9 @@ import type {RootTag} from '../../../../../Libraries/ReactNative/RootTag';
 import type {ViewConfig} from '../../../../../Libraries/Renderer/shims/ReactNativeTypes';
 import type HTMLCollection from '../oldstylecollections/HTMLCollection';
 import type {ReactNativeDocumentInstanceHandle} from './internals/ReactNativeDocumentInstanceHandle';
-import type ReadOnlyElement from './ReadOnlyElement';
 
 import {createHTMLCollection} from '../oldstylecollections/HTMLCollection';
+import {getPublicInstanceFromInstanceHandle} from './internals/NodeInternals';
 import {
   createReactNativeDocumentElementInstanceHandle,
   setNativeElementReferenceForReactNativeDocumentElementInstanceHandle,
@@ -24,10 +24,12 @@ import {
 } from './internals/ReactNativeDocumentElementInstanceHandle';
 import {createReactNativeDocumentInstanceHandle} from './internals/ReactNativeDocumentInstanceHandle';
 import ReactNativeElement from './ReactNativeElement';
+import ReadOnlyElement from './ReadOnlyElement';
 import ReadOnlyNode from './ReadOnlyNode';
 import NativeDOM from './specs/NativeDOM';
 
 export default class ReactNativeDocument extends ReadOnlyNode {
+  _rootTag: RootTag;
   _documentElement: ReactNativeElement;
 
   constructor(
@@ -35,6 +37,7 @@ export default class ReactNativeDocument extends ReadOnlyNode {
     instanceHandle: ReactNativeDocumentInstanceHandle,
   ) {
     super(instanceHandle, null);
+    this._rootTag = rootTag;
     this._documentElement = createDocumentElement(rootTag, this);
   }
 
@@ -71,10 +74,27 @@ export default class ReactNativeDocument extends ReadOnlyNode {
     return null;
   }
 
-  // $FlowExpectedError[incompatible-extend] This is defined as returning string in Node, but it's actually null in Document.
+  // $FlowExpectedError[incompatible-type] This is defined as returning string in Node, but it's actually null in Document.
   get textContent(): null {
     return null;
   }
+
+  getElementById(id: string): ReadOnlyElement | null {
+    const elementByIdInstanceHandle = NativeDOM.getElementById(
+      this._rootTag,
+      id,
+    );
+
+    if (elementByIdInstanceHandle == null) {
+      return null;
+    }
+
+    const elementById = getPublicInstanceFromInstanceHandle(
+      elementByIdInstanceHandle,
+    );
+
+    return elementById instanceof ReadOnlyElement ? elementById : null;
+  }
 }
 
 function createDocumentElement(

package/src/private/webapis/dom/nodes/ReactNativeElement.js

@@ -233,7 +233,7 @@ function replaceConstructorWithoutSuper(
 
   ReactNativeElement.prototype = ReactNativeElementClass.prototype;
 
-  // $FlowExpectedError[incompatible-return]
+  // $FlowExpectedError[incompatible-type]
   return ReactNativeElement;
 }
 

package/src/private/webapis/dom/nodes/ReadOnlyElement.js

@@ -220,9 +220,11 @@ export default class ReadOnlyElement extends ReadOnlyNode {
 }
 
 function getChildElements(node: ReadOnlyNode): $ReadOnlyArray<ReadOnlyElement> {
-  // $FlowIssue[incompatible-call]
-  return getChildNodes(node).filter(
-    childNode => childNode instanceof ReadOnlyElement,
+  // $FlowFixMe[incompatible-type]
+  return getChildNodes(
+    node,
+    (childNode: ReadOnlyNode) =>
+      childNode.nodeType === ReadOnlyNode.ELEMENT_NODE,
   );
 }
 

package/src/private/webapis/dom/nodes/ReadOnlyNode.js

@@ -118,7 +118,11 @@ export default class ReadOnlyNode {
   get parentElement(): ReadOnlyElement | null {
     const parentNode = this.parentNode;
 
-    if (parentNode instanceof getReadOnlyElementClass()) {
+    if (
+      parentNode != null &&
+      parentNode.nodeType === ReadOnlyNode.ELEMENT_NODE
+    ) {
+      // $FlowExpectedError[incompatible-type] parentNode is an instance of ReadOnlyElement as per the `nodeType` check
       return parentNode;
     }
 
@@ -292,6 +296,7 @@ setPlatformObject(ReadOnlyNode);
 
 export function getChildNodes(
   node: ReadOnlyNode,
+  filter?: (node: ReadOnlyNode) => boolean,
 ): $ReadOnlyArray<ReadOnlyNode> {
   const shadowNode = getNativeNodeReference(node);
 
@@ -300,9 +305,16 @@ export function getChildNodes(
   }
 
   const childNodeInstanceHandles = NativeDOM.getChildNodes(shadowNode);
-  return childNodeInstanceHandles
-    .map(instanceHandle => getPublicInstanceFromInstanceHandle(instanceHandle))
-    .filter(Boolean);
+  const childNodes = [];
+  for (const childNodeInstanceHandle of childNodeInstanceHandles) {
+    const childNode = getPublicInstanceFromInstanceHandle(
+      childNodeInstanceHandle,
+    );
+    if (childNode != null && (filter == null || filter(childNode))) {
+      childNodes.push(childNode);
+    }
+  }
+  return childNodes;
 }
 
 function getNodeSiblingsAndPosition(
@@ -323,12 +335,3 @@ function getNodeSiblingsAndPosition(
 
   return [siblings, position];
 }
-
-let ReadOnlyElementClass;
-function getReadOnlyElementClass(): Class<ReadOnlyElement> {
-  if (ReadOnlyElementClass == null) {
-    // We initialize this lazily to avoid a require cycle.
-    ReadOnlyElementClass = require('./ReadOnlyElement').default;
-  }
-  return ReadOnlyElementClass;
-}

package/src/private/webapis/dom/nodes/internals/NodeInternals.js

@@ -37,14 +37,30 @@ export type InstanceHandle =
   | ReactNativeDocumentElementInstanceHandle // root element managed by React Native
   | ReactNativeDocumentInstanceHandle; // document node managed by React Native
 
-let RendererProxy;
-function getRendererProxy() {
-  if (RendererProxy == null) {
+let cachedGetNodeFromInternalInstanceHandle;
+function getNodeFromInternalInstanceHandle(
+  instanceHandle: InternalInstanceHandle,
+) {
+  if (cachedGetNodeFromInternalInstanceHandle == null) {
     // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
     // With a static import we can't use these classes for Paper-only variants.
-    RendererProxy = require('../../../../../../Libraries/ReactNative/RendererProxy');
+    cachedGetNodeFromInternalInstanceHandle =
+      require('../../../../../../Libraries/ReactNative/RendererProxy').getNodeFromInternalInstanceHandle;
   }
-  return RendererProxy;
+  return cachedGetNodeFromInternalInstanceHandle(instanceHandle);
+}
+
+let cachedGetPublicInstanceFromInternalInstanceHandle;
+function getPublicInstanceFromInternalInstanceHandle(
+  instanceHandle: InternalInstanceHandle,
+) {
+  if (cachedGetPublicInstanceFromInternalInstanceHandle == null) {
+    // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
+    // With a static import we can't use these classes for Paper-only variants.
+    cachedGetPublicInstanceFromInternalInstanceHandle =
+      require('../../../../../../Libraries/ReactNative/RendererProxy').getPublicInstanceFromInternalInstanceHandle;
+  }
+  return cachedGetPublicInstanceFromInternalInstanceHandle(instanceHandle);
 }
 
 const INSTANCE_HANDLE_KEY = Symbol('internalInstanceHandle');
@@ -81,6 +97,15 @@ export function setOwnerDocument(
 export function getPublicInstanceFromInstanceHandle(
   instanceHandle: InstanceHandle,
 ): ?ReadOnlyNode {
+  const mixedPublicInstance =
+    // $FlowExpectedError[incompatible-type]
+    getPublicInstanceFromInternalInstanceHandle(instanceHandle);
+
+  if (mixedPublicInstance != null) {
+    // $FlowExpectedError[incompatible-type] React defines public instances as "mixed" because it can't access the definition from React Native.
+    return mixedPublicInstance;
+  }
+
   if (isReactNativeDocumentInstanceHandle(instanceHandle)) {
     return getPublicInstanceFromReactNativeDocumentInstanceHandle(
       instanceHandle,
@@ -92,14 +117,6 @@ export function getPublicInstanceFromInstanceHandle(
       instanceHandle,
     );
   }
-
-  const mixedPublicInstance =
-    getRendererProxy().getPublicInstanceFromInternalInstanceHandle(
-      instanceHandle,
-    );
-
-  // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
-  return mixedPublicInstance;
 }
 
 export function getNativeNodeReference(
@@ -107,6 +124,15 @@ export function getNativeNodeReference(
 ): ?NativeNodeReference {
   const instanceHandle = getInstanceHandle(node);
 
+  // Try React nodes first
+  const nativeReference =
+    // $FlowExpectedError[incompatible-type]
+    getNodeFromInternalInstanceHandle(instanceHandle);
+  if (nativeReference != null) {
+    // $FlowExpectedError[incompatible-type]
+    return nativeReference;
+  }
+
   if (isReactNativeDocumentInstanceHandle(instanceHandle)) {
     return getNativeNodeReferenceFromReactNativeDocumentInstanceHandle(
       instanceHandle,
@@ -118,15 +144,12 @@ export function getNativeNodeReference(
       instanceHandle,
     );
   }
-
-  // $FlowExpectedError[incompatible-return]
-  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
 }
 
 export function getNativeElementReference(
   node: ReadOnlyElement,
 ): ?NativeElementReference {
-  // $FlowExpectedError[incompatible-cast] We know ReadOnlyElement instances provide InternalInstanceHandle
+  // $FlowExpectedError[incompatible-type] We know ReadOnlyElement instances provide InternalInstanceHandle
   const instanceHandle = getInstanceHandle(node) as InternalInstanceHandle;
 
   if (isReactNativeDocumentElementInstanceHandle(instanceHandle)) {
@@ -135,16 +158,16 @@ export function getNativeElementReference(
     );
   }
 
-  // $FlowExpectedError[incompatible-return]
-  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+  // $FlowExpectedError[incompatible-type]
+  return getNodeFromInternalInstanceHandle(instanceHandle);
 }
 
 export function getNativeTextReference(
   node: ReadOnlyCharacterData,
 ): ?NativeTextReference {
-  // $FlowExpectedError[incompatible-cast] We know ReadOnlyText instances provide InternalInstanceHandle
+  // $FlowExpectedError[incompatible-type] We know ReadOnlyText instances provide InternalInstanceHandle
   const instanceHandle = getInstanceHandle(node) as InternalInstanceHandle;
 
-  // $FlowExpectedError[incompatible-return]
-  return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+  // $FlowExpectedError[incompatible-type]
+  return getNodeFromInternalInstanceHandle(instanceHandle);
 }

package/src/private/webapis/dom/nodes/internals/ReactNativeDocumentInstanceHandle.js

@@ -31,7 +31,7 @@ export function getNativeNodeReferenceFromReactNativeDocumentInstanceHandle(
 export function getPublicInstanceFromReactNativeDocumentInstanceHandle(
   instanceHandle: ReactNativeDocumentInstanceHandle,
 ): ?ReactNativeDocument {
-  // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
+  // $FlowExpectedError[incompatible-type] React defines public instances as "mixed" because it can't access the definition from React Native.
   return RendererProxy.getPublicInstanceFromRootTag(Number(instanceHandle));
 }