@office-iss/react-native-win32 0.80.0 → 0.81.0-preview.3

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/utils/ArrayLikeUtils.js

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 /**

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-win/Libraries/Components/View/ViewAccessibility.d.ts

@@ -417,6 +417,7 @@ export type AccessibilityAnnotationInfo = Readonly<{
   author?: string;
   dateTime?: string;
   target?: string;
+  replyCount?: number;
 }>;
 
 // [Win32]

package/src-win/Libraries/Components/View/ViewPropTypes.d.ts

@@ -13,14 +13,19 @@ import {GestureResponderHandlers} from 'react-native/types/public/ReactNativeRen
 import {StyleProp} from 'react-native/Libraries/StyleSheet/StyleSheet';
 import {ViewStyle} from 'react-native/Libraries/StyleSheet/StyleSheetTypes';
 import {
+  BlurEvent,
+  FocusEvent,
   LayoutChangeEvent,
+  PointerEvents,
   MouseEvent, // Win32
   NativeSyntheticEvent, // Win32
-  PointerEvents,
-} from 'react-native/Libraries/Types/CoreEventTypes';
+} from '../../Types/CoreEventTypes';
 import {Touchable} from 'react-native/Libraries/Components/Touchable/Touchable';
 import {AccessibilityProps} from './ViewAccessibility';
 
+/**
+ * @deprecated These properties are not implemented natively.
+ */
 export interface TVViewPropsIOS {
   /**
    * *(Apple TV only)* When set to true, this view will be focusable
@@ -34,6 +39,7 @@ export interface TVViewPropsIOS {
    * *(Apple TV only)* May be set to true to force the Apple TV focus engine to move focus to this view.
    *
    * @platform ios
+   * @deprecated Use `focusable` instead
    */
   hasTVPreferredFocus?: boolean | undefined;
 
@@ -81,6 +87,20 @@ export interface ViewPropsIOS extends TVViewPropsIOS {
 }
 
 export interface ViewPropsAndroid {
+  /**
+   * Callback that is called when the view is blurred.
+   *
+   * Note: This will only be called if the view is focusable.
+   */
+  onBlur?: ((e: BlurEvent) => void) | null | undefined;
+
+  /**
+   * Callback that is called when the view is focused.
+   *
+   * Note: This will only be called if the view is focusable.
+   */
+  onFocus?: ((e: FocusEvent) => void) | null | undefined;
+
   /**
    * Whether this view should render itself (and all of its children) into a single hardware texture on the GPU.
    *

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/modules/Devtools.d.ts

@@ -9,24 +9,38 @@
 
 declare module 'react-native/Libraries/Core/Devtools/parseErrorStack' {
   export type StackFrame = {
-    file: string;
+    column: number | null | undefined;
+    file: string | null | undefined;
+    lineNumber: number | null | undefined;
     methodName: string;
-    lineNumber: number;
-    column: number | null;
   };
 
-  export interface ExtendedError extends Error {
-    framesToPop?: number | undefined;
-  }
-
-  export default function parseErrorStack(error: ExtendedError): StackFrame[];
+  export default function parseErrorStack(errorStack?: string): StackFrame[];
 }
 
 declare module 'react-native/Libraries/Core/Devtools/symbolicateStackTrace' {
   import {StackFrame} from 'react-native/Libraries/Core/Devtools/parseErrorStack';
 
+  export type CodeFrame = Readonly<{
+    content: string;
+    location:
+      | {
+          row: number;
+          column: number;
+          [key: string]: any;
+        }
+      | null
+      | undefined;
+    fileName: string;
+  }>;
+
+  export type SymbolicatedStackTrace = Readonly<{
+    stack: ReadonlyArray<StackFrame>;
+    codeFrame: CodeFrame | null | undefined;
+  }>;
+
   export default function symbolicateStackTrace(
     stack: ReadonlyArray<StackFrame>,
     extraData?: any,
-  ): Promise<StackFrame[]>;
+  ): Promise<SymbolicatedStackTrace>;
 }

package/Libraries/BugReporting/BugReporting.js

@@ -1,140 +0,0 @@
-/**
- * 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.
- *
- * @format
- * @flow strict-local
- */
-
-import RCTDeviceEventEmitter from '../EventEmitter/RCTDeviceEventEmitter';
-import NativeRedBox from '../NativeModules/specs/NativeRedBox';
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
-import NativeBugReporting from './NativeBugReporting';
-
-type ExtraData = {[key: string]: string, ...};
-type SourceCallback = () => string;
-type DebugData = {
-  extras: ExtraData,
-  files: ExtraData,
-  ...
-};
-
-function defaultExtras() {
-  BugReporting.addFileSource('react_hierarchy.txt', () =>
-    require('./dumpReactTree').default(),
-  );
-}
-
-/**
- * A simple class for collecting bug report data. Components can add sources that will be queried when a bug report
- * is created via `collectExtraData`. For example, a list component might add a source that provides the list of rows
- * that are currently visible on screen. Components should also remember to call `remove()` on the object that is
- * returned by `addSource` when they are unmounted.
- */
-class BugReporting {
-  static _extraSources: Map<string, SourceCallback> = new Map();
-  static _fileSources: Map<string, SourceCallback> = new Map();
-  static _subscription: ?EventSubscription = null;
-  static _redboxSubscription: ?EventSubscription = null;
-
-  static _maybeInit() {
-    if (!BugReporting._subscription) {
-      BugReporting._subscription = RCTDeviceEventEmitter.addListener(
-        'collectBugExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-      defaultExtras();
-    }
-
-    if (!BugReporting._redboxSubscription) {
-      BugReporting._redboxSubscription = RCTDeviceEventEmitter.addListener(
-        'collectRedBoxExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-    }
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._extraSources);
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addFileSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._fileSources);
-  }
-
-  static _addSource(
-    key: string,
-    callback: SourceCallback,
-    source: Map<string, SourceCallback>,
-  ): {remove: () => void, ...} {
-    BugReporting._maybeInit();
-    if (source.has(key)) {
-      console.warn(
-        `BugReporting.add* called multiple times for same key '${key}'`,
-      );
-    }
-    source.set(key, callback);
-    return {
-      remove: () => {
-        source.delete(key);
-      },
-    };
-  }
-
-  /**
-   * This can be called from a native bug reporting flow, or from JS code.
-   *
-   * If available, this will call `NativeModules.BugReporting.setExtraData(extraData)`
-   * after collecting `extraData`.
-   */
-  static collectExtraData(): DebugData {
-    const extraData: ExtraData = {};
-    for (const [key, callback] of BugReporting._extraSources) {
-      extraData[key] = callback();
-    }
-    const fileData: ExtraData = {};
-    for (const [key, callback] of BugReporting._fileSources) {
-      fileData[key] = callback();
-    }
-
-    if (NativeBugReporting != null && NativeBugReporting.setExtraData != null) {
-      NativeBugReporting.setExtraData(extraData, fileData);
-    }
-
-    if (NativeRedBox != null && NativeRedBox.setExtraData != null) {
-      NativeRedBox.setExtraData(extraData, 'From BugReporting.js');
-    }
-
-    return {extras: extraData, files: fileData};
-  }
-}
-
-export default BugReporting;

package/Libraries/BugReporting/NativeBugReporting.js

@@ -1,13 +0,0 @@
-/**
- * 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
- */
-
-export * from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-import NativeBugReporting from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-export default NativeBugReporting;