@office-iss/react-native-win32 0.81.2 → 0.82.0-preview.2

package/src/private/webapis/intersectionobserver/internals/IntersectionObserverManager.js

@@ -27,13 +27,13 @@ import type {NativeIntersectionObserverToken} from '../specs/NativeIntersectionO
 
 import * as Systrace from '../../../../../Libraries/Performance/Systrace';
 import warnOnce from '../../../../../Libraries/Utilities/warnOnce';
-import * as ReactNativeFeatureFlags from '../../../featureflags/ReactNativeFeatureFlags';
 import {
   getInstanceHandle,
   getNativeNodeReference,
 } from '../../dom/nodes/internals/NodeInternals';
 import {createIntersectionObserverEntry} from '../IntersectionObserverEntry';
 import NativeIntersectionObserver from '../specs/NativeIntersectionObserver';
+import nullthrows from 'nullthrows';
 
 export type IntersectionObserverId = number;
 
@@ -69,36 +69,11 @@ function setTargetForInstanceHandle(
   instanceHandleToTargetMap.set(key, target);
 }
 
-// The mapping between ReactNativeElement and their corresponding shadow node
-// also needs to be kept here because React removes the link when unmounting.
-const targetToShadowNodeMap: WeakMap<
-  ReactNativeElement,
-  ReturnType<typeof getNativeNodeReference>,
-> = new WeakMap();
-
 const targetToTokenMap: WeakMap<
   ReactNativeElement,
   NativeIntersectionObserverToken,
 > = new WeakMap();
 
-let modernNativeIntersectionObserver =
-  NativeIntersectionObserver == null
-    ? null
-    : NativeIntersectionObserver.observeV2 == null ||
-        NativeIntersectionObserver.unobserveV2 == null
-      ? null
-      : {
-          observe: NativeIntersectionObserver.observeV2,
-          unobserve: NativeIntersectionObserver.unobserveV2,
-        };
-
-if (
-  modernNativeIntersectionObserver &&
-  !ReactNativeFeatureFlags.utilizeTokensInIntersectionObserver()
-) {
-  modernNativeIntersectionObserver = null;
-}
-
 /**
  * Registers the given intersection observer and returns a unique ID for it,
  * which is required to start observing targets.
@@ -189,34 +164,19 @@ export function observe({
   // access it even after the instance handle has been unmounted.
   setTargetForInstanceHandle(instanceHandle, target);
 
-  if (modernNativeIntersectionObserver == null) {
-    // Same for the mapping between the target and its shadow node.
-    targetToShadowNodeMap.set(target, targetNativeNodeReference);
-  }
-
   if (!isConnected) {
     NativeIntersectionObserver.connect(notifyIntersectionObservers);
     isConnected = true;
   }
 
-  if (modernNativeIntersectionObserver == null) {
-    NativeIntersectionObserver.observe({
-      intersectionObserverId,
-      rootShadowNode: rootNativeNodeReference,
-      targetShadowNode: targetNativeNodeReference,
-      thresholds: registeredObserver.observer.thresholds,
-      rootThresholds: registeredObserver.observer.rnRootThresholds,
-    });
-  } else {
-    const token = modernNativeIntersectionObserver.observe({
-      intersectionObserverId,
-      rootShadowNode: rootNativeNodeReference,
-      targetShadowNode: targetNativeNodeReference,
-      thresholds: registeredObserver.observer.thresholds,
-      rootThresholds: registeredObserver.observer.rnRootThresholds,
-    });
-    targetToTokenMap.set(target, token);
-  }
+  const token = nullthrows(NativeIntersectionObserver.observeV2)({
+    intersectionObserverId,
+    rootShadowNode: rootNativeNodeReference,
+    targetShadowNode: targetNativeNodeReference,
+    thresholds: registeredObserver.observer.thresholds,
+    rootThresholds: registeredObserver.observer.rnRootThresholds,
+  });
+  targetToTokenMap.set(target, token);
 
   return true;
 }
@@ -240,33 +200,18 @@ export function unobserve(
     return;
   }
 
-  if (modernNativeIntersectionObserver == null) {
-    const targetNativeNodeReference = targetToShadowNodeMap.get(target);
-    if (targetNativeNodeReference == null) {
-      console.error(
-        'IntersectionObserverManager: could not find registration data for target',
-      );
-      return;
-    }
-
-    NativeIntersectionObserver.unobserve(
-      intersectionObserverId,
-      targetNativeNodeReference,
-    );
-  } else {
-    const targetToken = targetToTokenMap.get(target);
-    if (targetToken == null) {
-      console.error(
-        'IntersectionObserverManager: could not find registration data for target',
-      );
-      return;
-    }
-
-    modernNativeIntersectionObserver.unobserve(
-      intersectionObserverId,
-      targetToken,
+  const targetToken = targetToTokenMap.get(target);
+  if (targetToken == null) {
+    console.error(
+      'IntersectionObserverManager: could not find registration data for target',
     );
+    return;
   }
+
+  nullthrows(NativeIntersectionObserver.unobserveV2)(
+    intersectionObserverId,
+    targetToken,
+  );
 }
 
 /**

package/src/private/webapis/intersectionobserver/specs/NativeIntersectionObserver.js

@@ -34,10 +34,6 @@ export type NativeIntersectionObserverObserveOptions = {
 export opaque type NativeIntersectionObserverToken = mixed;
 
 export interface Spec extends TurboModule {
-  // TODO(T223605846): Remove legacy observe method
-  +observe: (options: NativeIntersectionObserverObserveOptions) => void;
-  // TODO(T223605846): Remove legacy unobserve method
-  +unobserve: (intersectionObserverId: number, targetShadowNode: mixed) => void;
   +observeV2?: (
     options: NativeIntersectionObserverObserveOptions,
   ) => NativeIntersectionObserverToken;

package/src/private/webapis/mutationobserver/internals/MutationObserverManager.js

@@ -111,7 +111,7 @@ export function observe({
       // the public instance immediately when mutations occur. Otherwise React
       // could dereference it in the instance handle and we wouldn't be able to
       // access it.
-      // $FlowExpectedError[incompatible-call] This is typed as (mixed) => mixed in the native module because the codegen doesn't support the actual types.
+      // $FlowExpectedError[incompatible-type] This is typed as (mixed) => mixed in the native module because the codegen doesn't support the actual types.
       getPublicInstanceFromInternalInstanceHandle,
     );
     isConnected = true;

package/src/private/webapis/performance/EventTiming.js

@@ -9,15 +9,17 @@
  */
 
 // flowlint unsafe-getters-setters:off
-
 import type {
   DOMHighResTimeStamp,
+  PerformanceEntryInit,
   PerformanceEntryJSON,
 } from './PerformanceEntry';
 
-import {warnNoNativePerformance} from './internals/Utilities';
 import {PerformanceEntry} from './PerformanceEntry';
-import NativePerformance from './specs/NativePerformance';
+import MaybeNativePerformance from './specs/NativePerformance';
+import nullthrows from 'nullthrows';
+
+const NativePerformance = nullthrows(MaybeNativePerformance);
 
 export type PerformanceEventTimingJSON = {
   ...PerformanceEntryJSON,
@@ -27,25 +29,20 @@ export type PerformanceEventTimingJSON = {
   ...
 };
 
+export interface PerformanceEventTimingInit extends PerformanceEntryInit {
+  +processingStart?: DOMHighResTimeStamp;
+  +processingEnd?: DOMHighResTimeStamp;
+  +interactionId?: number;
+}
+
 export class PerformanceEventTiming extends PerformanceEntry {
   #processingStart: DOMHighResTimeStamp;
   #processingEnd: DOMHighResTimeStamp;
   #interactionId: number;
 
-  constructor(init: {
-    name: string,
-    startTime?: DOMHighResTimeStamp,
-    duration?: DOMHighResTimeStamp,
-    processingStart?: DOMHighResTimeStamp,
-    processingEnd?: DOMHighResTimeStamp,
-    interactionId?: number,
-  }) {
-    super({
-      name: init.name,
-      entryType: 'event',
-      startTime: init.startTime ?? 0,
-      duration: init.duration ?? 0,
-    });
+  constructor(init: PerformanceEventTimingInit) {
+    super('event', init);
+
     this.#processingStart = init.processingStart ?? 0;
     this.#processingEnd = init.processingEnd ?? 0;
     this.#interactionId = init.interactionId ?? 0;
@@ -73,6 +70,18 @@ export class PerformanceEventTiming extends PerformanceEntry {
   }
 }
 
+export const PerformanceEventTiming_public: typeof PerformanceEventTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceEventTiming() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceEventTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceEventTiming_public.prototype = PerformanceEventTiming.prototype;
+
 type EventCountsForEachCallbackType =
   | (() => void)
   | ((value: number) => void)
@@ -86,18 +95,12 @@ function getCachedEventCounts(): Map<string, number> {
     return cachedEventCounts;
   }
 
-  if (!NativePerformance || !NativePerformance?.getEventCounts) {
-    warnNoNativePerformance();
-    cachedEventCounts = new Map();
-    return cachedEventCounts;
-  }
-
   const eventCounts = new Map<string, number>(
-    NativePerformance.getEventCounts?.() ?? [],
+    NativePerformance.getEventCounts() ?? [],
   );
   cachedEventCounts = eventCounts;
 
-  // $FlowFixMe[incompatible-call]
+  // $FlowFixMe[incompatible-type]
   global.queueMicrotask(() => {
     // To be consistent with the calls to the API from the same task,
     // but also not to refetch the data from native too often,
@@ -143,3 +146,15 @@ export class EventCounts {
     return getCachedEventCounts().values();
   }
 }
+
+export const EventCounts_public: typeof EventCounts =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function EventCounts() {
+    throw new TypeError(
+      "Failed to construct 'EventCounts': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+EventCounts_public.prototype = EventCounts.prototype;

package/src/private/webapis/performance/LongTasks.js

@@ -9,8 +9,10 @@
  */
 
 // flowlint unsafe-getters-setters:off
-
-import type {PerformanceEntryJSON} from './PerformanceEntry';
+import type {
+  PerformanceEntryInit,
+  PerformanceEntryJSON,
+} from './PerformanceEntry';
 
 import {PerformanceEntry} from './PerformanceEntry';
 
@@ -22,10 +24,28 @@ export type PerformanceLongTaskTimingJSON = {
 
 export class TaskAttributionTiming extends PerformanceEntry {}
 
+export const TaskAttributionTiming_public: typeof TaskAttributionTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function TaskAttributionTiming() {
+    throw new TypeError(
+      "Failed to construct 'TaskAttributionTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+TaskAttributionTiming_public.prototype = TaskAttributionTiming.prototype;
+
 const EMPTY_ATTRIBUTION: $ReadOnlyArray<TaskAttributionTiming> =
   Object.preventExtensions([]);
 
+export interface PerformanceLongTaskTimingInit extends PerformanceEntryInit {}
+
 export class PerformanceLongTaskTiming extends PerformanceEntry {
+  constructor(init: PerformanceEntryInit) {
+    super('longtask', init);
+  }
+
   get attribution(): $ReadOnlyArray<TaskAttributionTiming> {
     return EMPTY_ATTRIBUTION;
   }
@@ -37,3 +57,16 @@ export class PerformanceLongTaskTiming extends PerformanceEntry {
     };
   }
 }
+
+export const PerformanceLongTaskTiming_public: typeof PerformanceLongTaskTiming =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function PerformanceLongTaskTiming() {
+    throw new TypeError(
+      "Failed to construct 'PerformanceLongTaskTiming': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+PerformanceLongTaskTiming_public.prototype =
+  PerformanceLongTaskTiming.prototype;