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

package/Libraries/Utilities/Platform.ios.js

@@ -0,0 +1,88 @@
+/**
+ * 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
+ */
+
+import type {
+  Platform as PlatformType,
+  PlatformSelectSpec,
+} from './Platform.flow';
+
+import NativePlatformConstantsIOS from './NativePlatformConstantsIOS';
+
+const Platform: PlatformType = {
+  __constants: null,
+  OS: 'ios',
+  // $FlowFixMe[unsafe-getters-setters]
+  get Version(): string {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.osVersion;
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get constants(): {|
+    forceTouchAvailable: boolean,
+    interfaceIdiom: string,
+    isTesting: boolean,
+    isDisableAnimations?: boolean,
+    osVersion: string,
+    reactNativeVersion: {|
+      major: number,
+      minor: number,
+      patch: number,
+      prerelease: ?string,
+    |},
+    systemName: string,
+    isMacCatalyst?: boolean,
+  |} {
+    // $FlowFixMe[object-this-reference]
+    if (this.__constants == null) {
+      // $FlowFixMe[object-this-reference]
+      this.__constants = NativePlatformConstantsIOS.getConstants();
+    }
+    // $FlowFixMe[object-this-reference]
+    return this.__constants;
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isPad(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.interfaceIdiom === 'pad';
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTV(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.interfaceIdiom === 'tv';
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isVision(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.interfaceIdiom === 'vision';
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isTesting(): boolean {
+    if (__DEV__) {
+      // $FlowFixMe[object-this-reference]
+      return this.constants.isTesting;
+    }
+    return false;
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isDisableAnimations(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.isDisableAnimations ?? this.isTesting;
+  },
+  // $FlowFixMe[unsafe-getters-setters]
+  get isMacCatalyst(): boolean {
+    // $FlowFixMe[object-this-reference]
+    return this.constants.isMacCatalyst ?? false;
+  },
+  select: <T>(spec: PlatformSelectSpec<T>): T =>
+    // $FlowFixMe[incompatible-return]
+    'ios' in spec ? spec.ios : 'native' in spec ? spec.native : spec.default,
+};
+
+module.exports = Platform;

package/Libraries/Utilities/Platform.js.flow

@@ -0,0 +1,13 @@
+/**
+ * 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 type {Platform} from './Platform.flow';
+
+declare module.exports: Platform;

package/Libraries/Utilities/PolyfillFunctions.js

@@ -0,0 +1,56 @@
+/**
+ * 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 defineLazyObjectProperty = require('./defineLazyObjectProperty');
+
+/**
+ * Sets an object's property. If a property with the same name exists, this will
+ * replace it but maintain its descriptor configuration. The property will be
+ * replaced with a lazy getter.
+ *
+ * In DEV mode the original property value will be preserved as `original[PropertyName]`
+ * so that, if necessary, it can be restored. For example, if you want to route
+ * network requests through DevTools (to trace them):
+ *
+ *   global.XMLHttpRequest = global.originalXMLHttpRequest;
+ *
+ * @see https://github.com/facebook/react-native/issues/934
+ */
+function polyfillObjectProperty<T>(
+  object: {...},
+  name: string,
+  getValue: () => T,
+): void {
+  const descriptor = Object.getOwnPropertyDescriptor<$FlowFixMe>(object, name);
+  if (__DEV__ && descriptor) {
+    const backupName = `original${name[0].toUpperCase()}${name.slice(1)}`;
+    Object.defineProperty(object, backupName, descriptor);
+  }
+
+  const {enumerable, writable, configurable = false} = descriptor || {};
+  if (descriptor && !configurable) {
+    console.error('Failed to set polyfill. ' + name + ' is not configurable.');
+    return;
+  }
+
+  defineLazyObjectProperty(object, name, {
+    get: getValue,
+    enumerable: enumerable !== false,
+    writable: writable !== false,
+  });
+}
+
+function polyfillGlobal<T>(name: string, getValue: () => T): void {
+  polyfillObjectProperty(global, name, getValue);
+}
+
+module.exports = {polyfillObjectProperty, polyfillGlobal};

package/Libraries/Utilities/RCTLog.js

@@ -0,0 +1,56 @@
+/**
+ * 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';
+
+const invariant = require('invariant');
+
+const levelsMap = {
+  log: 'log',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+  fatal: 'error',
+};
+
+let warningHandler: ?(...Array<mixed>) => void = null;
+
+const RCTLog = {
+  // level one of log, info, warn, error, mustfix
+  logIfNoNativeHook(level: string, ...args: Array<mixed>): void {
+    // We already printed in the native console, so only log here if using a js debugger
+    if (typeof global.nativeLoggingHook === 'undefined') {
+      RCTLog.logToConsole(level, ...args);
+    } else {
+      // Report native warnings to LogBox
+      if (warningHandler && level === 'warn') {
+        warningHandler(...args);
+      }
+    }
+  },
+
+  // Log to console regardless of nativeLoggingHook
+  logToConsole(level: string, ...args: Array<mixed>): void {
+    // $FlowFixMe[invalid-computed-prop]
+    const logFn = levelsMap[level];
+    invariant(
+      logFn,
+      'Level "' + level + '" not one of ' + Object.keys(levelsMap).toString(),
+    );
+
+    console[logFn](...args);
+  },
+
+  setWarningHandler(handler: typeof warningHandler): void {
+    warningHandler = handler;
+  },
+};
+
+module.exports = RCTLog;

package/Libraries/Utilities/ReactNativeTestTools.js

@@ -0,0 +1,225 @@
+/**
+ * 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
+ * @format
+ */
+
+/* eslint-env jest */
+
+import type {ReactTestRenderer as ReactTestRendererType} from 'react-test-renderer';
+
+import TouchableWithoutFeedback from '../Components/Touchable/TouchableWithoutFeedback';
+
+const Switch = require('../Components/Switch/Switch').default;
+const TextInput = require('../Components/TextInput/TextInput');
+const View = require('../Components/View/View');
+const Text = require('../Text/Text');
+const {VirtualizedList} = require('@react-native/virtualized-lists');
+const React = require('react');
+const ReactTestRenderer = require('react-test-renderer');
+
+export type ReactTestInstance = $PropertyType<ReactTestRendererType, 'root'>;
+export type Predicate = (node: ReactTestInstance) => boolean;
+/* $FlowFixMe[value-as-type] (>=0.125.1 site=react_native_fb) This comment
+ * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
+ * delete this comment and run Flow. */
+export type ReactTestRendererJSON =
+  /* $FlowFixMe[prop-missing] (>=0.125.1 site=react_native_fb) This comment
+   * suppresses an error found when Flow v0.125.1 was deployed. To see the error,
+   * delete this comment and run Flow. */
+  ReturnType<ReactTestRenderer.create.toJSON>;
+
+function byClickable(): Predicate {
+  return withMessage(
+    node =>
+      // note: <Text /> lazy-mounts press handlers after the first press,
+      //       so this is a workaround for targeting text nodes.
+      (node.type === Text &&
+        node.props &&
+        typeof node.props.onPress === 'function') ||
+      // note: Special casing <Switch /> since it doesn't use touchable
+      (node.type === Switch && node.props && node.props.disabled !== true) ||
+      (node.type === View &&
+        node?.props?.onStartShouldSetResponder?.testOnly_pressabilityConfig) ||
+      (node.type === TouchableWithoutFeedback &&
+        node.props &&
+        typeof node.props.onPress === 'function') ||
+      // HACK: Find components that use `Pressability`.
+      node.instance?.state?.pressability != null ||
+      // TODO: Remove this after deleting `Touchable`.
+      (node.instance != null &&
+        // $FlowFixMe[prop-missing]
+        typeof node.instance.touchableHandlePress === 'function'),
+    'is clickable',
+  );
+}
+
+function byTestID(testID: string): Predicate {
+  return withMessage(
+    node => node.props && node.props.testID === testID,
+    `testID prop equals ${testID}`,
+  );
+}
+
+function byTextMatching(regex: RegExp): Predicate {
+  return withMessage(
+    node => node.props != null && regex.exec(node.props.children) !== null,
+    `text content matches ${regex.toString()}`,
+  );
+}
+
+function enter(instance: ReactTestInstance, text: string) {
+  const input = instance.findByType(TextInput);
+  input.props.onChange && input.props.onChange({nativeEvent: {text}});
+  input.props.onChangeText && input.props.onChangeText(text);
+}
+
+// Returns null if there is no error, otherwise returns an error message string.
+function maximumDepthError(
+  tree: ReactTestRendererType,
+  maxDepthLimit: number,
+): ?string {
+  const maxDepth = maximumDepthOfJSON(tree.toJSON());
+  if (maxDepth > maxDepthLimit) {
+    return (
+      `maximumDepth of ${maxDepth} exceeded limit of ${maxDepthLimit} - this is a proxy ` +
+      'metric to protect against stack overflow errors:\n\n' +
+      'https://fburl.com/rn-view-stack-overflow.\n\n' +
+      'To fix, you need to remove native layers from your hierarchy, such as unnecessary View ' +
+      'wrappers.'
+    );
+  } else {
+    return null;
+  }
+}
+
+function expectNoConsoleWarn() {
+  (jest: $FlowFixMe).spyOn(console, 'warn').mockImplementation((...args) => {
+    expect(args).toBeFalsy();
+  });
+}
+
+function expectNoConsoleError() {
+  let hasNotFailed = true;
+  (jest: $FlowFixMe).spyOn(console, 'error').mockImplementation((...args) => {
+    if (hasNotFailed) {
+      hasNotFailed = false; // set false to prevent infinite recursion
+      expect(args).toBeFalsy();
+    }
+  });
+}
+
+async function expectRendersMatchingSnapshot(
+  name: string,
+  ComponentProvider: () => React.MixedElement,
+  unmockComponent: () => mixed,
+) {
+  let instance;
+
+  jest.resetAllMocks();
+
+  await ReactTestRenderer.act(() => {
+    instance = ReactTestRenderer.create(<ComponentProvider />);
+  });
+  expect(instance).toMatchSnapshot(
+    'should deep render when mocked (please verify output manually)',
+  );
+
+  jest.resetAllMocks();
+  unmockComponent();
+
+  await ReactTestRenderer.act(() => {
+    instance = ReactTestRenderer.create(<ComponentProvider />);
+  });
+  expect(instance).toMatchSnapshot(
+    'should deep render when not mocked (please verify output manually)',
+  );
+}
+
+// Takes a node from toJSON()
+function maximumDepthOfJSON(node: ?ReactTestRendererJSON): number {
+  if (node == null) {
+    return 0;
+  } else if (typeof node === 'string' || node.children == null) {
+    return 1;
+  } else {
+    let maxDepth = 0;
+    node.children.forEach(child => {
+      maxDepth = Math.max(maximumDepthOfJSON(child) + 1, maxDepth);
+    });
+    return maxDepth;
+  }
+}
+
+function renderAndEnforceStrictMode(element: React.Node): any {
+  expectNoConsoleError();
+  return renderWithStrictMode(element);
+}
+
+function renderWithStrictMode(element: React.Node): ReactTestRendererType {
+  const WorkAroundBugWithStrictModeInTestRenderer = (prps: {
+    children: React.Node,
+  }) => prps.children;
+  const StrictMode = (React: $FlowFixMe).StrictMode;
+  return ReactTestRenderer.create(
+    <WorkAroundBugWithStrictModeInTestRenderer>
+      <StrictMode>{element}</StrictMode>
+    </WorkAroundBugWithStrictModeInTestRenderer>,
+  );
+}
+
+function tap(instance: ReactTestInstance) {
+  const touchable = instance.find(byClickable());
+  if (touchable.type === Text && touchable.props && touchable.props.onPress) {
+    touchable.props.onPress();
+  } else if (touchable.type === Switch && touchable.props) {
+    const value = !touchable.props.value;
+    const {onChange, onValueChange} = touchable.props;
+    onChange && onChange({nativeEvent: {value}});
+    onValueChange && onValueChange(value);
+  } else if (
+    touchable?.props?.onStartShouldSetResponder?.testOnly_pressabilityConfig
+  ) {
+    const {onPress, disabled} =
+      touchable.props.onStartShouldSetResponder.testOnly_pressabilityConfig();
+    if (!disabled) {
+      onPress({nativeEvent: {}});
+    }
+  } else {
+    // Only tap when props.disabled isn't set (or there aren't any props)
+    if (!touchable.props || !touchable.props.disabled) {
+      touchable.props.onPress({nativeEvent: {}});
+    }
+  }
+}
+
+function scrollToBottom(instance: ReactTestInstance) {
+  const list = instance.findByType(VirtualizedList);
+  list.props && list.props.onEndReached();
+}
+
+// To make error messages a little bit better, we attach a custom toString
+// implementation to a predicate
+function withMessage(fn: Predicate, message: string): Predicate {
+  (fn: any).toString = () => message;
+  return fn;
+}
+
+export {byClickable};
+export {byTestID};
+export {byTextMatching};
+export {enter};
+export {expectNoConsoleWarn};
+export {expectNoConsoleError};
+export {expectRendersMatchingSnapshot};
+export {maximumDepthError};
+export {maximumDepthOfJSON};
+export {renderAndEnforceStrictMode};
+export {renderWithStrictMode};
+export {scrollToBottom};
+export {tap};
+export {withMessage};

package/Libraries/Utilities/SceneTracker.js

@@ -0,0 +1,42 @@
+/**
+ * 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';
+
+export type Scene = {name: string, [string]: mixed, ...};
+
+let _listeners: Array<(scene: Scene) => void> = [];
+
+let _activeScene = {name: 'default'};
+
+const SceneTracker = {
+  setActiveScene(scene: Scene) {
+    _activeScene = scene;
+    _listeners.forEach(listener => listener(_activeScene));
+  },
+
+  getActiveScene(): Scene {
+    return _activeScene;
+  },
+
+  addActiveSceneChangedListener(callback: (scene: Scene) => void): {
+    remove: () => void,
+    ...
+  } {
+    _listeners.push(callback);
+    return {
+      remove: () => {
+        _listeners = _listeners.filter(listener => callback !== listener);
+      },
+    };
+  },
+};
+
+module.exports = SceneTracker;

package/Libraries/Utilities/__mocks__/BackHandler.js

@@ -0,0 +1,45 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const _backPressSubscriptions = new Set();
+
+const BackHandler = {
+  exitApp: jest.fn(),
+
+  addEventListener: function (
+    eventName: BackPressEventName,
+    handler: () => ?boolean,
+  ): {remove: () => void} {
+    _backPressSubscriptions.add(handler);
+    return {
+      remove: () => {
+        _backPressSubscriptions.delete(handler);
+      },
+    };
+  },
+
+  mockPressBack: function () {
+    let invokeDefault = true;
+    const subscriptions = [..._backPressSubscriptions].reverse();
+    for (let i = 0; i < subscriptions.length; ++i) {
+      if (subscriptions[i]()) {
+        invokeDefault = false;
+        break;
+      }
+    }
+
+    if (invokeDefault) {
+      BackHandler.exitApp();
+    }
+  },
+};
+
+module.exports = BackHandler;

package/Libraries/Utilities/__mocks__/GlobalPerformanceLogger.js

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const GlobalPerformanceLogger = jest
+  .unmock('../createPerformanceLogger')
+  .genMockFromModule('../GlobalPerformanceLogger');
+
+module.exports = GlobalPerformanceLogger;

package/Libraries/Utilities/__mocks__/PixelRatio.js

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+const PixelRatio = {
+  get: jest.fn().mockReturnValue(2),
+  getFontScale: jest.fn(() => PixelRatio.get()),
+  getPixelSizeForLayoutSize: jest.fn(layoutSize =>
+    Math.round(layoutSize * PixelRatio.get()),
+  ),
+  roundToNearestPixel: jest.fn(layoutSize => {
+    const ratio = PixelRatio.get();
+    return Math.round(layoutSize * ratio) / ratio;
+  }),
+  startDetecting: jest.fn(),
+};
+
+export default PixelRatio;

package/Libraries/Utilities/binaryToBase64.js

@@ -0,0 +1,31 @@
+/**
+ * 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';
+
+const base64 = require('base64-js');
+
+function binaryToBase64(data: ArrayBuffer | $ArrayBufferView): string {
+  if (data instanceof ArrayBuffer) {
+    // $FlowFixMe[reassign-const]
+    data = new Uint8Array(data);
+  }
+  if (data instanceof Uint8Array) {
+    return base64.fromByteArray(data);
+  }
+  if (!ArrayBuffer.isView(data)) {
+    throw new Error('data must be ArrayBuffer or typed array');
+  }
+  // Already checked that `data` is `DataView` in `ArrayBuffer.isView(data)`
+  const {buffer, byteOffset, byteLength}: DataView = (data: $FlowFixMe);
+  return base64.fromByteArray(new Uint8Array(buffer, byteOffset, byteLength));
+}
+
+module.exports = binaryToBase64;

package/Libraries/Utilities/codegenNativeCommands.js

@@ -0,0 +1,31 @@
+/**
+ * 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
+ */
+
+const {dispatchCommand} = require('../ReactNative/RendererProxy');
+
+type Options<T = string> = $ReadOnly<{|
+  supportedCommands: $ReadOnlyArray<T>,
+|}>;
+
+function codegenNativeCommands<T: interface {}>(options: Options<$Keys<T>>): T {
+  const commandObj: {[$Keys<T>]: (...$ReadOnlyArray<mixed>) => void} = {};
+
+  options.supportedCommands.forEach(command => {
+    // $FlowFixMe[missing-local-annot]
+    commandObj[command] = (ref, ...args) => {
+      // $FlowFixMe[incompatible-call]
+      dispatchCommand(ref, command, args);
+    };
+  });
+
+  return ((commandObj: any): T);
+}
+
+export default codegenNativeCommands;