@react-native-oh/react-native-harmony 0.72.86 → 0.77.18-1

package/Libraries/Utilities/codegenNativeComponent.js

@@ -0,0 +1,73 @@
+/**
+ * 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
+ */
+
+// TODO: move this file to shims/ReactNative (requires React update and sync)
+
+import type {HostComponent} from '../../Libraries/Renderer/shims/ReactNativeTypes';
+
+import requireNativeComponent from '../../Libraries/ReactNative/requireNativeComponent';
+import UIManager from '../ReactNative/UIManager';
+
+// TODO: import from CodegenSchema once workspaces are enabled
+type Options = $ReadOnly<{|
+  interfaceOnly?: boolean,
+  paperComponentName?: string,
+  paperComponentNameDeprecated?: string,
+  excludedPlatforms?: $ReadOnlyArray<'iOS' | 'android'>,
+|}>;
+
+export type NativeComponentType<T> = HostComponent<T>;
+
+// If this function runs then that means the view configs were not
+// generated at build time using `GenerateViewConfigJs.js`. Thus
+// we need to `requireNativeComponent` to get the view configs from view managers.
+// `requireNativeComponent` is not available in Bridgeless mode.
+// e.g. This function runs at runtime if `codegenNativeComponent` was not called
+// from a file suffixed with NativeComponent.js.
+function codegenNativeComponent<Props: {...}>(
+  componentName: string,
+  options?: Options,
+): NativeComponentType<Props> {
+  if (global.RN$Bridgeless === true && __DEV__) {
+    console.warn(
+      `Codegen didn't run for ${componentName}. This will be an error in the future. Make sure you are using @react-native/babel-preset when building your JavaScript code.`,
+    );
+  }
+
+  let componentNameInUse =
+    options && options.paperComponentName != null
+      ? options.paperComponentName
+      : componentName;
+
+  if (options != null && options.paperComponentNameDeprecated != null) {
+    if (UIManager.hasViewManagerConfig(componentName)) {
+      componentNameInUse = componentName;
+    } else if (
+      options.paperComponentNameDeprecated != null &&
+      UIManager.hasViewManagerConfig(options.paperComponentNameDeprecated)
+    ) {
+      // $FlowFixMe[incompatible-type]
+      componentNameInUse = options.paperComponentNameDeprecated;
+    } else {
+      throw new Error(
+        `Failed to find native component for either ${componentName} or ${
+          options.paperComponentNameDeprecated ?? '(unknown)'
+        }`,
+      );
+    }
+  }
+
+  return (requireNativeComponent<Props>(
+    // $FlowFixMe[incompatible-call]
+    componentNameInUse,
+  ): HostComponent<Props>);
+}
+
+export default codegenNativeComponent;

package/Libraries/Utilities/{createPerformanceLogger.harmony.js → createPerformanceLogger.js}

@@ -8,55 +8,19 @@
  * @format
  */
 
-const Systrace = require('react-native/Libraries/Performance/Systrace'); // RNOH: patch
-const infoLog = require('react-native/Libraries/Utilities/infoLog'); // RNOH: patch
+import type {
+  Extras,
+  ExtraValue,
+  IPerformanceLogger,
+  Timespan,
+} from './IPerformanceLogger';
 
-export type Timespan = {
-  startTime: number,
-  endTime?: number,
-  totalTime?: number,
-  startExtras?: Extras,
-  endExtras?: Extras,
-};
-
-// Extra values should be serializable primitives
-export type ExtraValue = number | string | boolean;
-
-export type Extras = {[key: string]: ExtraValue};
-
-export interface IPerformanceLogger {
-  addTimespan(
-    key: string,
-    startTime: number,
-    endTime: number,
-    startExtras?: Extras,
-    endExtras?: Extras,
-  ): void;
-  append(logger: IPerformanceLogger): void;
-  clear(): void;
-  clearCompleted(): void;
-  close(): void;
-  currentTimestamp(): number;
-  getExtras(): $ReadOnly<{[key: string]: ?ExtraValue, ...}>;
-  getPoints(): $ReadOnly<{[key: string]: ?number, ...}>;
-  getPointExtras(): $ReadOnly<{[key: string]: ?Extras, ...}>;
-  getTimespans(): $ReadOnly<{[key: string]: ?Timespan, ...}>;
-  hasTimespan(key: string): boolean;
-  isClosed(): boolean;
-  logEverything(): void;
-  markPoint(key: string, timestamp?: number, extras?: Extras): void;
-  removeExtra(key: string): ?ExtraValue;
-  setExtra(key: string, value: ExtraValue): void;
-  startTimespan(key: string, timestamp?: number, extras?: Extras): void;
-  stopTimespan(key: string, timestamp?: number, extras?: Extras): void;
-}
-
-const _cookies: {[key: string]: number, ...} = {};
+import infoLog from './infoLog';
 
 const PRINT_TO_CONSOLE: false = false; // Type as false to prevent accidentally committing `true`;
 
 export const getCurrentTimestamp: () => number =
-  global.nativeQPLTimestamp ?? global.performance ? global.performance.now.bind(global.performance) : Date.now; // RNOH: patch
+  global.nativeQPLTimestamp ?? global.performance ? global.performance.now.bind(global.performance) : Date.now; // RNC_patch
 
 class PerformanceLogger implements IPerformanceLogger {
   _timespans: {[key: string]: ?Timespan} = {};
@@ -266,7 +230,6 @@ class PerformanceLogger implements IPerformanceLogger {
       startTime: timestamp,
       startExtras: extras,
     };
-    _cookies[key] = Systrace.beginAsyncEvent(key);
     if (PRINT_TO_CONSOLE) {
       infoLog('PerformanceLogger.js', 'start: ' + key);
     }
@@ -310,14 +273,13 @@ class PerformanceLogger implements IPerformanceLogger {
     if (PRINT_TO_CONSOLE) {
       infoLog('PerformanceLogger.js', 'end: ' + key);
     }
-
-    if (_cookies[key] != null) {
-      Systrace.endAsyncEvent(key, _cookies[key]);
-      delete _cookies[key];
-    }
   }
 }
 
+// Re-exporting for backwards compatibility with all the clients that
+// may still import it from this module.
+export type {Extras, ExtraValue, IPerformanceLogger, Timespan};
+
 /**
  * This function creates performance loggers that can be used to collect and log
  * various performance data such as timespans, points and extras.

package/Libraries/Utilities/deepFreezeAndThrowOnMutationInDev.js

@@ -0,0 +1,90 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * If your application is accepting different values for the same field over
+ * time and is doing a diff on them, you can either (1) create a copy or
+ * (2) ensure that those values are not mutated behind two passes.
+ * This function helps you with (2) by freezing the object and throwing if
+ * the user subsequently modifies the value.
+ *
+ * There are two caveats with this function:
+ *   - If the call site is not in strict mode, it will only throw when
+ *     mutating existing fields, adding a new one
+ *     will unfortunately fail silently :(
+ *   - If the object is already frozen or sealed, it will not continue the
+ *     deep traversal and will leave leaf nodes unfrozen.
+ *
+ * Freezing the object and adding the throw mechanism is expensive and will
+ * only be used in DEV.
+ */
+function deepFreezeAndThrowOnMutationInDev<T: {...} | Array<mixed>>(
+  object: T,
+): T {
+  if (__DEV__) {
+    if (
+      typeof object !== 'object' ||
+      object === null ||
+      Object.isFrozen(object) ||
+      Object.isSealed(object)
+    ) {
+      return object;
+    }
+
+    // $FlowFixMe[not-an-object] `object` can be an array, but Object.keys works with arrays too
+    const keys = Object.keys((object: {...} | Array<mixed>));
+    // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (hasOwnProperty.call(object, key)) {
+        Object.defineProperty(object, key, {
+          get: identity.bind(null, object[key]),
+        });
+        Object.defineProperty(object, key, {
+          set: throwOnImmutableMutation.bind(null, key),
+        });
+      }
+    }
+
+    Object.freeze(object);
+    Object.seal(object);
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (hasOwnProperty.call(object, key)) {
+        deepFreezeAndThrowOnMutationInDev(object[key]);
+      }
+    }
+  }
+  return object;
+}
+
+/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+ * LTI update could not be added via codemod */
+function throwOnImmutableMutation(key: empty, value) {
+  throw Error(
+    'You attempted to set the key `' +
+      key +
+      '` with the value `' +
+      JSON.stringify(value) +
+      '` on an object that is meant to be immutable ' +
+      'and has been frozen.',
+  );
+}
+
+function identity(value: mixed) {
+  return value;
+}
+
+module.exports = deepFreezeAndThrowOnMutationInDev;

package/Libraries/Utilities/defineLazyObjectProperty.js

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Defines a lazily evaluated property on the supplied `object`.
+ */
+function defineLazyObjectProperty<T>(
+  object: interface {},
+  name: string,
+  descriptor: {
+    get: () => T,
+    enumerable?: boolean,
+    writable?: boolean,
+    ...
+  },
+): void {
+  const {get} = descriptor;
+  const enumerable = descriptor.enumerable !== false;
+  const writable = descriptor.writable !== false;
+
+  let value;
+  let valueSet = false;
+  function getValue(): T {
+    // WORKAROUND: A weird infinite loop occurs where calling `getValue` calls
+    // `setValue` which calls `Object.defineProperty` which somehow triggers
+    // `getValue` again. Adding `valueSet` breaks this loop.
+    if (!valueSet) {
+      // Calling `get()` here can trigger an infinite loop if it fails to
+      // remove the getter on the property, which can happen when executing
+      // JS in a V8 context.  `valueSet = true` will break this loop, and
+      // sets the value of the property to undefined, until the code in `get()`
+      // finishes, at which point the property is set to the correct value.
+      valueSet = true;
+      setValue(get());
+    }
+    return value;
+  }
+  function setValue(newValue: T): void {
+    value = newValue;
+    valueSet = true;
+    Object.defineProperty(object, name, {
+      value: newValue,
+      configurable: true,
+      enumerable,
+      writable,
+    });
+  }
+
+  Object.defineProperty(object, name, {
+    get: getValue,
+    set: setValue,
+    configurable: true,
+    enumerable,
+  });
+}
+
+module.exports = defineLazyObjectProperty;

package/Libraries/Utilities/differ/deepDiffer.js

@@ -0,0 +1,101 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+let logListeners;
+
+type LogListeners = {|
+  +onDifferentFunctionsIgnored: (nameOne: ?string, nameTwo: ?string) => void,
+|};
+
+type Options = {|+unsafelyIgnoreFunctions?: boolean|};
+
+function unstable_setLogListeners(listeners: ?LogListeners) {
+  logListeners = listeners;
+}
+
+/*
+ * @returns {bool} true if different, false if equal
+ */
+const deepDiffer = function (
+  one: any,
+  two: any,
+  maxDepthOrOptions: Options | number = -1,
+  maybeOptions?: Options,
+): boolean {
+  const options =
+    typeof maxDepthOrOptions === 'number' ? maybeOptions : maxDepthOrOptions;
+  const maxDepth =
+    typeof maxDepthOrOptions === 'number' ? maxDepthOrOptions : -1;
+  if (maxDepth === 0) {
+    return true;
+  }
+  if (one === two) {
+    // Short circuit on identical object references instead of traversing them.
+    return false;
+  }
+  if (typeof one === 'function' && typeof two === 'function') {
+    // We consider all functions equal unless explicitly configured otherwise
+    let unsafelyIgnoreFunctions = options?.unsafelyIgnoreFunctions;
+    if (unsafelyIgnoreFunctions == null) {
+      if (
+        logListeners &&
+        logListeners.onDifferentFunctionsIgnored &&
+        (!options || !('unsafelyIgnoreFunctions' in options))
+      ) {
+        logListeners.onDifferentFunctionsIgnored(one.name, two.name);
+      }
+      unsafelyIgnoreFunctions = true;
+    }
+    return !unsafelyIgnoreFunctions;
+  }
+  if (typeof one !== 'object' || one === null) {
+    // Primitives can be directly compared
+    return one !== two;
+  }
+  if (typeof two !== 'object' || two === null) {
+    // We know they are different because the previous case would have triggered
+    // otherwise.
+    return true;
+  }
+  if (one.constructor !== two.constructor) {
+    return true;
+  }
+  if (Array.isArray(one)) {
+    // We know two is also an array because the constructors are equal
+    const len = one.length;
+    if (two.length !== len) {
+      return true;
+    }
+    for (let ii = 0; ii < len; ii++) {
+      if (deepDiffer(one[ii], two[ii], maxDepth - 1, options)) {
+        return true;
+      }
+    }
+  } else {
+    for (const key in one) {
+      if (deepDiffer(one[key], two[key], maxDepth - 1, options)) {
+        return true;
+      }
+    }
+    for (const twoKey in two) {
+      // The only case we haven't checked yet is keys that are in two but aren't
+      // in one, which means they are different.
+      if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+deepDiffer.unstable_setLogListeners = unstable_setLogListeners;
+module.exports = deepDiffer;

package/Libraries/Utilities/differ/insetsDiffer.js

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+type Inset = {
+  top: ?number,
+  left: ?number,
+  right: ?number,
+  bottom: ?number,
+  ...
+};
+
+const dummyInsets = {
+  top: undefined,
+  left: undefined,
+  right: undefined,
+  bottom: undefined,
+};
+
+const insetsDiffer = function (one: Inset, two: Inset): boolean {
+  one = one || dummyInsets;
+  two = two || dummyInsets;
+  return (
+    one !== two &&
+    (one.top !== two.top ||
+      one.left !== two.left ||
+      one.right !== two.right ||
+      one.bottom !== two.bottom)
+  );
+};
+
+module.exports = insetsDiffer;

package/Libraries/Utilities/differ/matricesDiffer.js

@@ -0,0 +1,51 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Unrolls an array comparison specially for matrices. Prioritizes
+ * checking of indices that are most likely to change so that the comparison
+ * bails as early as possible.
+ *
+ * @param {MatrixMath.Matrix} one First matrix.
+ * @param {MatrixMath.Matrix} two Second matrix.
+ * @return {boolean} Whether or not the two matrices differ.
+ */
+const matricesDiffer = function (
+  one: ?Array<number>,
+  two: ?Array<number>,
+): boolean {
+  if (one === two) {
+    return false;
+  }
+  return (
+    !one ||
+    !two ||
+    one[12] !== two[12] ||
+    one[13] !== two[13] ||
+    one[14] !== two[14] ||
+    one[5] !== two[5] ||
+    one[10] !== two[10] ||
+    one[0] !== two[0] ||
+    one[1] !== two[1] ||
+    one[2] !== two[2] ||
+    one[3] !== two[3] ||
+    one[4] !== two[4] ||
+    one[6] !== two[6] ||
+    one[7] !== two[7] ||
+    one[8] !== two[8] ||
+    one[9] !== two[9] ||
+    one[11] !== two[11] ||
+    one[15] !== two[15]
+  );
+};
+
+module.exports = matricesDiffer;

package/Libraries/Utilities/differ/pointsDiffer.js

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+type Point = {
+  x: ?number,
+  y: ?number,
+  ...
+};
+
+const dummyPoint = {x: undefined, y: undefined};
+
+const pointsDiffer = function (one: ?Point, two: ?Point): boolean {
+  one = one || dummyPoint;
+  two = two || dummyPoint;
+  return one !== two && (one.x !== two.x || one.y !== two.y);
+};
+
+module.exports = pointsDiffer;

package/Libraries/Utilities/differ/sizesDiffer.js

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const dummySize = {width: undefined, height: undefined};
+type Size = {width: ?number, height: ?number};
+
+const sizesDiffer = function (one: Size, two: Size): boolean {
+  const defaultedOne = one || dummySize;
+  const defaultedTwo = two || dummySize;
+  return (
+    defaultedOne !== defaultedTwo &&
+    (defaultedOne.width !== defaultedTwo.width ||
+      defaultedOne.height !== defaultedTwo.height)
+  );
+};
+
+module.exports = sizesDiffer;

package/Libraries/Utilities/dismissKeyboard.js

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+
+// This function dismisses the currently-open keyboard, if any.
+
+'use strict';
+
+const TextInputState = require('../Components/TextInput/TextInputState');
+
+function dismissKeyboard() {
+  TextInputState.blurTextInput(TextInputState.currentlyFocusedInput());
+}
+
+module.exports = dismissKeyboard;

package/Libraries/Utilities/infoLog.js

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Intentional info-level logging for clear separation from ad-hoc console debug logging.
+ */
+function infoLog(...args: Array<mixed>): void {
+  return console.log(...args);
+}
+
+module.exports = infoLog;

package/Libraries/Utilities/logError.js

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Small utility that can be used as an error handler. You cannot just pass
+ * `console.error` as a failure callback - it's not properly bound.  If passes an
+ * `Error` object, it will print the message and stack.
+ */
+const logError = function (...args: $ReadOnlyArray<mixed>) {
+  if (args.length === 1 && args[0] instanceof Error) {
+    const err = args[0];
+    console.error('Error: "' + err.message + '".  Stack:\n' + err.stack);
+  } else {
+    console.error.apply(console, args);
+  }
+};
+
+module.exports = logError;

package/Libraries/Utilities/mapWithSeparator.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.
+ *
+ * @format
+ * @flow strict
+ */
+
+'use strict';
+
+function mapWithSeparator<TFrom, TTo>(
+  items: Array<TFrom>,
+  itemRenderer: (item: TFrom, index: number, items: Array<TFrom>) => TTo,
+  spacerRenderer: (index: number) => TTo,
+): Array<TTo> {
+  const mapped = [];
+  if (items.length > 0) {
+    mapped.push(itemRenderer(items[0], 0, items));
+    for (let ii = 1; ii < items.length; ii++) {
+      mapped.push(spacerRenderer(ii - 1), itemRenderer(items[ii], ii, items));
+    }
+  }
+  return mapped;
+}
+
+module.exports = mapWithSeparator;