@office-iss/react-native-win32 0.0.0-canary.296 → 0.0.0-canary.297

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

@@ -43,6 +43,7 @@ const registeredMutationObservers: Map<
 
 // The mapping between ReactNativeElement and their corresponding shadow node
 // needs to be kept here because React removes the link when unmounting.
+// TODO: remove this code when NativeMutationObserver.unobserveAll is available in all apps
 const targetToShadowNodeMap: WeakMap<
   ReactNativeElement,
   ReturnType<typeof getNativeNodeReference>,
@@ -111,7 +112,11 @@ export function observe({
     return false;
   }
 
-  targetToShadowNodeMap.set(target, targetShadowNode);
+  // We need to keep this temporarily until the changes in the native module have propagated.
+  // After that, we don't need to keep this mapping that can cause memory leaks.
+  if (!nativeUnobserveAll) {
+    targetToShadowNodeMap.set(target, targetShadowNode);
+  }
 
   if (!isConnected) {
     NativeMutationObserver.connect(
@@ -135,34 +140,61 @@ export function observe({
   return true;
 }
 
-export function unobserve(
+const nativeUnobserve = NativeMutationObserver?.unobserve;
+
+// TODO: delete in the next version, when NativeMutationObserver.unobserveAll is available in all apps
+export const unobserve: ?(
   mutationObserverId: number,
   target: ReactNativeElement,
-): void {
-  if (NativeMutationObserver == null) {
-    warnNoNativeMutationObserver();
-    return;
-  }
+) => void = nativeUnobserve
+  ? function unobserve(
+      mutationObserverId: number,
+      target: ReactNativeElement,
+    ): void {
+      if (NativeMutationObserver == null) {
+        warnNoNativeMutationObserver();
+        return;
+      }
 
-  const registeredObserver =
-    registeredMutationObservers.get(mutationObserverId);
-  if (registeredObserver == null) {
-    console.error(
-      `MutationObserverManager: could not stop observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
-    );
-    return;
-  }
+      const registeredObserver =
+        registeredMutationObservers.get(mutationObserverId);
+      if (registeredObserver == null) {
+        console.error(
+          `MutationObserverManager: could not stop observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
+        );
+        return;
+      }
 
-  const targetShadowNode = targetToShadowNodeMap.get(target);
-  if (targetShadowNode == null) {
-    console.error(
-      'MutationObserverManager: could not find registration data for target',
-    );
-    return;
-  }
+      const targetShadowNode = targetToShadowNodeMap.get(target);
+      if (targetShadowNode == null) {
+        console.error(
+          'MutationObserverManager: could not find registration data for target',
+        );
+        return;
+      }
 
-  NativeMutationObserver.unobserve(mutationObserverId, targetShadowNode);
-}
+      nativeUnobserve(mutationObserverId, targetShadowNode);
+    }
+  : null;
+
+const nativeUnobserveAll = NativeMutationObserver?.unobserveAll;
+
+// TODO: clean up as a regular export in the next version, when NativeMutationObserver.unobserveAll is available in all apps
+export const unobserveAll: ?(mutationObserverId: number) => void =
+  nativeUnobserveAll
+    ? function unobserveAll(mutationObserverId: MutationObserverId): void {
+        const registeredObserver =
+          registeredMutationObservers.get(mutationObserverId);
+        if (registeredObserver == null) {
+          console.error(
+            `MutationObserverManager: could not stop observing target because MutationObserver with ID ${mutationObserverId} was not registered.`,
+          );
+          return;
+        }
+
+        nativeUnobserveAll(mutationObserverId);
+      }
+    : null;
 
 /**
  * This function is called from native when there are `MutationObserver`

package/src/private/webapis/mutationobserver/specs/NativeMutationObserver.js

@@ -36,10 +36,13 @@ export type NativeMutationObserverObserveOptions = {
 
 export interface Spec extends TurboModule {
   +observe: (options: NativeMutationObserverObserveOptions) => void;
-  +unobserve: (
+  // TODO: remove in the next version
+  +unobserve?: (
     mutationObserverId: number,
     targetShadowNode: ShadowNode,
   ) => void;
+  // TODO: remove optionality in the next version
+  +unobserveAll?: (mutationObserverId: number) => void;
   +connect: (
     notifyMutationObservers: () => void,
     // We need this to retain the public instance before React removes the

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

@@ -6,11 +6,12 @@
  *
  * @flow strict
  * @format
- * @oncall react_native
  */
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 type MemoryInfoLike = {
   jsHeapSizeLimit: ?number,
   totalJSHeapSize: ?number,
@@ -52,3 +53,5 @@ export default class MemoryInfo {
     return this.#usedJSHeapSize;
   }
 }
+
+setPlatformObject(MemoryInfo);

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

@@ -17,6 +17,8 @@ import type {
 } from './PerformanceEntry';
 import type {DetailType, PerformanceMarkOptions} from './UserTiming';
 
+import DOMException from '../errors/DOMException';
+import {setPlatformObject} from '../webidl/PlatformObjects';
 import {EventCounts} from './EventTiming';
 import {
   performanceEntryTypeToRaw,
@@ -191,15 +193,22 @@ export default class Performance {
     let computedDuration = duration;
 
     if (NativePerformance?.measureWithResult) {
-      [computedStartTime, computedDuration] =
-        NativePerformance.measureWithResult(
-          measureName,
-          startTime,
-          endTime,
-          duration,
-          startMarkName,
-          endMarkName,
+      try {
+        [computedStartTime, computedDuration] =
+          NativePerformance.measureWithResult(
+            measureName,
+            startTime,
+            endTime,
+            duration,
+            startMarkName,
+            endMarkName,
+          );
+      } catch (error) {
+        throw new DOMException(
+          "Failed to execute 'measure' on 'Performance': " + error.message,
+          'SyntaxError',
         );
+      }
     } else {
       warnNoNativePerformance();
     }
@@ -283,3 +292,5 @@ export default class Performance {
     ).map(rawToPerformanceEntry);
   }
 }
+
+setPlatformObject(Performance);

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

@@ -10,6 +10,8 @@
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 export type DOMHighResTimeStamp = number;
 export type PerformanceEntryType =
   | 'mark'
@@ -70,4 +72,6 @@ export class PerformanceEntry {
   }
 }
 
+setPlatformObject(PerformanceEntry);
+
 export type PerformanceEntryList = $ReadOnlyArray<PerformanceEntry>;

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

@@ -6,11 +6,12 @@
  *
  * @flow strict
  * @format
- * @oncall react_native
  */
 
 // flowlint unsafe-getters-setters:off
 
+import {setPlatformObject} from '../webidl/PlatformObjects';
+
 type ReactNativeStartupTimingLike = {
   startTime: ?number,
   endTime: ?number,
@@ -89,3 +90,5 @@ export default class ReactNativeStartupTiming {
     return this.#executeJavaScriptBundleEntryPointEnd;
   }
 }
+
+setPlatformObject(ReactNativeStartupTiming);

package/src/private/webapis/performance/internals/RawPerformanceEntry.js

@@ -77,6 +77,8 @@ export function rawToPerformanceEntryType(
       return 'event';
     case RawPerformanceEntryTypeValues.LONGTASK:
       return 'longtask';
+    case RawPerformanceEntryTypeValues.RESOURCE:
+      return 'resource';
     default:
       throw new TypeError(
         `rawToPerformanceEntryType: unexpected performance entry type received: ${type}`,

package/src/private/webapis/structuredClone/structuredClone.js

@@ -0,0 +1,233 @@
+/**
+ * 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 DOMException from '../errors/DOMException';
+import {
+  getPlatformObjectClone,
+  isPlatformObject,
+} from '../webidl/PlatformObjects';
+
+const VALID_ERROR_NAMES = new Set([
+  'Error',
+  'EvalError',
+  'RangeError',
+  'ReferenceError',
+  'SyntaxError',
+  'TypeError',
+  'URIError',
+]);
+
+const BASIC_CONSTRUCTORS = [Number, String, Boolean, Date];
+
+const ObjectPrototype = Object.prototype;
+
+// Technicall the memory value should be a parameter in
+// `structuredCloneInternal` but as an optimization we can reuse the same map
+// and avoid allocating a new one in every call to `structuredClone`.
+// This is safe because we don't invoke user code in `structuredClone`, so at
+// any given point we only have one memory object alive anyway.
+const memory: Map<mixed, mixed> = new Map();
+
+function structuredCloneInternal<T>(value: T): T {
+  // Handles `null` and `undefined`.
+  if (value == null) {
+    return value;
+  }
+
+  // Handles remaining primitive values.
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'bigint':
+      return value;
+  }
+
+  // Handles unsupported types (symbols and functions).
+  if (typeof value !== 'object') {
+    // value is symbol or function
+    throw new DOMException(
+      `Failed to execute 'structuredClone' on 'Window': ${String(value)} could not be cloned.`,
+      'DataCloneError',
+    );
+  }
+
+  // Handles circular references.
+  if (memory.has(value)) {
+    // $FlowExpectedError[incompatible-return] we know memory.get(value) is T
+    return memory.get(value);
+  }
+
+  // Handles arrays.
+  if (Array.isArray(value)) {
+    const result = [];
+    memory.set(value, result);
+
+    for (const key of Object.keys(value)) {
+      result[key] = structuredCloneInternal(value[key]);
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Simple object fast path
+  // $FlowIssue[prop-missing] Why doesn't Flow know about Object.prototype?
+  if (Object.getPrototypeOf(value) === ObjectPrototype) {
+    const result = {};
+    memory.set(value, result);
+
+    for (const key of Object.keys(value)) {
+      // $FlowExpectedError[prop-missing]
+      result[key] = structuredCloneInternal(value[key]);
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Handles complex types (typeof === 'object').
+
+  for (const Cls of BASIC_CONSTRUCTORS) {
+    if (value instanceof Cls) {
+      const result = new Cls(value);
+      memory.set(value, result);
+      // $FlowExpectedError[incompatible-return] we know result is T
+      return result;
+    }
+  }
+
+  if (value instanceof Map) {
+    const result = new Map<mixed, mixed>();
+    memory.set(value, result);
+
+    for (const [innerKey, innerValue] of value) {
+      result.set(
+        structuredCloneInternal(innerKey),
+        structuredCloneInternal(innerValue),
+      );
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  if (value instanceof Set) {
+    const result = new Set<mixed>();
+    memory.set(value, result);
+
+    for (const innerValue of value) {
+      result.add(structuredCloneInternal(innerValue));
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  if (value instanceof RegExp) {
+    const result = new RegExp(value.source, value.flags);
+    memory.set(value, result);
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // We need to check platform objects before `Error` because `DOMException`
+  // is a platform object AND an `Error` subclass.
+  const clone = getPlatformObjectClone(value);
+  if (clone != null) {
+    const result = clone(value);
+    memory.set(value, result);
+    return result;
+  }
+
+  if (value instanceof Error) {
+    const result = value.cause
+      ? new Error(value.message, {cause: value.cause})
+      : new Error(value.message);
+    memory.set(value, result);
+
+    if (VALID_ERROR_NAMES.has(value.name)) {
+      result.name = value.name;
+    } else {
+      result.name = 'Error';
+    }
+
+    result.stack = value.stack;
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Known non-serializable objects.
+  if (isNonSerializableObject(value) || isPlatformObject(value)) {
+    throw new DOMException(
+      `Failed to execute 'structuredClone' on 'Window': ${String(value)} could not be cloned.`,
+      'DataCloneError',
+    );
+  }
+
+  // Arbitrary object slow path
+  const result = {};
+  memory.set(value, result);
+
+  // We need to use Object.keys instead of iterating by indices because we
+  // also need to copy arbitrary fields set in the array.
+  for (const key of Object.keys(value)) {
+    // $FlowExpectedError[prop-missing]
+    result[key] = structuredCloneInternal(value[key]);
+  }
+
+  // $FlowExpectedError[incompatible-return] we know result is T
+  return result;
+}
+
+/**
+ * Basic implementation of `structuredClone`.
+ * See:
+ * - https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone.
+ * - https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+ * - https://html.spec.whatwg.org/multipage/structured-data.html#structured-cloning
+ *
+ * Supports cloning all built-in types supported by the spec, circular
+ * references and referential equality of the same objects found in the
+ * structure.
+ *
+ * Shortcuts:
+ * - This implementation does NOT serialize and deserialize the value
+ *   but implements the cloning in a single step.
+ *
+ * Known limitations:
+ * - It does not support transfering values.
+ */
+export default function structuredClone<T>(value: T): T {
+  try {
+    return structuredCloneInternal(value);
+  } finally {
+    memory.clear();
+  }
+}
+
+const NON_SERIALIZABLE_OBJECT_KEY = Symbol('nonSerializableObject');
+
+function isNonSerializableObject<T: interface {}>(obj: T): boolean {
+  // $FlowExpectedError[invalid-in-lhs]
+  return NON_SERIALIZABLE_OBJECT_KEY in obj;
+}
+
+function markClassAsNonSerializable<T>(cls: Class<T>): void {
+  // $FlowExpectedError[incompatible-use]
+  cls.prototype[NON_SERIALIZABLE_OBJECT_KEY] = true;
+}
+
+// Non-serializable built-ins.
+markClassAsNonSerializable(WeakMap);
+markClassAsNonSerializable(WeakSet);
+markClassAsNonSerializable(Promise);

package/src/private/webapis/webidl/PlatformObjects.js

@@ -0,0 +1,59 @@
+/**
+ * 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
+ */
+
+const IS_PLATFORM_OBJECT_KEY = Symbol('isPlatformObject');
+const CLONE_PLATFORM_OBJECT_KEY = Symbol('clonePlatformObject');
+
+/**
+ * Marks the given object or instances of the given class as platform objects.
+ *
+ * Optionally, it sets the clone function for that platform object, which is a
+ * simplification of the serializable attribute of the Web interface.
+ */
+export const setPlatformObject: (<T: interface {}>(
+  obj: Class<T>,
+  options?: {clone: T => T},
+) => void) &
+  (<T: interface {}>(obj: T, options?: {clone: T => T}) => void) =
+  function setPlatformObject(obj, options) {
+    if (typeof obj === 'function') {
+      // $FlowExpectedError[prop-missing]
+      obj.prototype[IS_PLATFORM_OBJECT_KEY] = true;
+      if (options) {
+        // $FlowExpectedError[prop-missing]
+        obj.prototype[CLONE_PLATFORM_OBJECT_KEY] = options.clone;
+      }
+    } else {
+      // $FlowExpectedError[prop-missing]
+      obj[IS_PLATFORM_OBJECT_KEY] = true;
+      if (options) {
+        // $FlowExpectedError[prop-missing]
+        obj[CLONE_PLATFORM_OBJECT_KEY] = options.clone;
+      }
+    }
+  };
+
+/**
+ * Indicates if the given object is a platform object.
+ */
+export function isPlatformObject<T: interface {}>(obj: T): boolean {
+  // $FlowExpectedError[invalid-in-lhs]
+  return IS_PLATFORM_OBJECT_KEY in obj;
+}
+
+/**
+ * Returns the clone function for the given platform object, if it was set.
+ */
+export function getPlatformObjectClone<T: interface {}>(
+  obj: T,
+): (T => T) | void {
+  // $FlowExpectedError[prop-missing]
+  return obj[CLONE_PLATFORM_OBJECT_KEY];
+}

package/src/types/globals.d.ts

@@ -57,6 +57,48 @@ declare global {
 
   const HermesInternal: null | {};
 
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly) */
+  interface DOMRectReadOnly {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/bottom) */
+    readonly bottom: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/height) */
+    readonly height: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/left) */
+    readonly left: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/right) */
+    readonly right: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/top) */
+    readonly top: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/width) */
+    readonly width: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/x) */
+    readonly x: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRectReadOnly/y) */
+    readonly y: number;
+    toJSON(): any;
+  }
+
+  interface DOMRect extends DOMRectReadOnly {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+  }
+
+  interface DOMRectInit {
+    height?: number | undefined;
+    width?: number | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+  }
+
+  var DOMRect: {
+    prototype: DOMRect;
+    new (x?: number, y?: number, width?: number, height?: number): DOMRect;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMRect/fromRect_static) */
+    fromRect(other?: DOMRectInit): DOMRect;
+  };
+
   // #region Timer Functions
 
   function clearInterval(handle: number): void;

package/src-win/Libraries/Text/Text.d.ts

@@ -296,6 +296,13 @@ export interface TextProps
    * Controls how touch events are handled. Similar to `View`'s `pointerEvents`.
    */
   pointerEvents?: ViewStyle['pointerEvents'] | undefined;
+
+  /**
+   * Defines how far your touch may move off of the button, before deactivating the button.
+   */
+  pressRetentionOffset?:
+    | {top: number; left: number; bottom: number; right: number}
+    | undefined;
 }
 
 /**

package/types/index.d.ts

@@ -68,7 +68,7 @@
 /// <reference path="modules/BatchedBridge.d.ts" />
 /// <reference path="modules/Codegen.d.ts" />
 /// <reference path="modules/Devtools.d.ts" />
-/// <reference types="../src/types/globals.d.ts" />
+/// <reference path="../src/types/globals.d.ts" />
 
 export * from '../Libraries/ActionSheetIOS/ActionSheetIOS';
 export * from '../Libraries/Alert/Alert';