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

package/Libraries/ReactNative/BridgelessUIManager.js

@@ -0,0 +1,430 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import type {RootTag} from '../Types/RootTagTypes';
+import type {UIManagerJSInterface} from '../Types/UIManagerJSInterface';
+
+import {unstable_hasComponent} from '../NativeComponent/NativeComponentRegistryUnstable';
+import defineLazyObjectProperty from '../Utilities/defineLazyObjectProperty';
+import Delegate from './delegates/BridgelessUIManagerDelegate';
+import {getFabricUIManager} from './FabricUIManager';
+import nullthrows from 'nullthrows';
+import Platform from '../Utilities/Platform';
+
+
+const DELEGATE = new Delegate({});
+
+// RNC_patch
+const PatchedPlatform = {
+  select(implementationByPlatformName) {
+    return implementationByPlatformName[DELEGATE.selectAndroidOrIOSImplementation()];
+  },
+};
+
+function raiseSoftError(methodName: string, details?: string): void {
+  console.error(
+    `[ReactNative Architecture][JS] '${methodName}' is not available in the new React Native architecture.` +
+      (details ? ` ${details}` : ''),
+  );
+}
+
+const getUIManagerConstants: ?() => {[viewManagerName: string]: Object} =
+  global.RN$LegacyInterop_UIManager_getConstants;
+
+const getUIManagerConstantsCached = (function () {
+  let wasCalledOnce = false;
+  let result = {};
+  return (): {[viewManagerName: string]: Object} => {
+    if (!wasCalledOnce) {
+      result = nullthrows(getUIManagerConstants)();
+      wasCalledOnce = true;
+    }
+    return result;
+  };
+})();
+
+const getConstantsForViewManager: ?(viewManagerName: string) => ?Object =
+  global.RN$LegacyInterop_UIManager_getConstantsForViewManager;
+
+const getDefaultEventTypes: ?() => Object =
+  global.RN$LegacyInterop_UIManager_getDefaultEventTypes;
+
+const getDefaultEventTypesCached = (function () {
+  let wasCalledOnce = false;
+  let result = null;
+  return (): Object => {
+    if (!wasCalledOnce) {
+      result = nullthrows(getDefaultEventTypes)();
+      wasCalledOnce = true;
+    }
+    return result;
+  };
+})();
+
+/**
+ * UIManager.js overrides these APIs.
+ * Pull them out from the BridgelessUIManager implementation. So, we can ignore them.
+ */
+const UIManagerJSOverridenAPIs = {
+  measure: (
+    reactTag: number,
+    callback: (
+      left: number,
+      top: number,
+      width: number,
+      height: number,
+      pageX: number,
+      pageY: number,
+    ) => void,
+  ): void => {
+    raiseSoftError('measure');
+  },
+  measureInWindow: (
+    reactTag: number,
+    callback: (x: number, y: number, width: number, height: number) => void,
+  ): void => {
+    raiseSoftError('measureInWindow');
+  },
+  measureLayout: (
+    reactTag: number,
+    ancestorReactTag: number,
+    errorCallback: (error: Object) => void,
+    callback: (
+      left: number,
+      top: number,
+      width: number,
+      height: number,
+    ) => void,
+  ): void => {
+    raiseSoftError('measureLayout');
+  },
+  measureLayoutRelativeToParent: (
+    reactTag: number,
+    errorCallback: (error: Object) => void,
+    callback: (
+      left: number,
+      top: number,
+      width: number,
+      height: number,
+    ) => void,
+  ): void => {
+    raiseSoftError('measureLayoutRelativeToParent');
+  },
+  dispatchViewManagerCommand: (
+    reactTag: number,
+    commandID: number,
+    commandArgs: ?Array<string | number | boolean>,
+  ): void => {
+    raiseSoftError('dispatchViewManagerCommand');
+  },
+};
+
+/**
+ * Leave Unimplemented: The only thing that called these methods was the paper renderer.
+ * In OSS, the New Architecture will just use the Fabric renderer, which uses
+ * different APIs.
+ */
+const UIManagerJSUnusedInNewArchAPIs = {
+  createView: (
+    reactTag: number,
+    viewName: string,
+    rootTag: RootTag,
+    props: Object,
+  ): void => {
+    raiseSoftError('createView');
+  },
+  updateView: (reactTag: number, viewName: string, props: Object): void => {
+    raiseSoftError('updateView');
+  },
+  setChildren: (containerTag: number, reactTags: Array<number>): void => {
+    raiseSoftError('setChildren');
+  },
+  manageChildren: (
+    containerTag: number,
+    moveFromIndices: Array<number>,
+    moveToIndices: Array<number>,
+    addChildReactTags: Array<number>,
+    addAtIndices: Array<number>,
+    removeAtIndices: Array<number>,
+  ): void => {
+    raiseSoftError('manageChildren');
+  },
+  setJSResponder: (reactTag: number, blockNativeResponder: boolean): void => {
+    raiseSoftError('setJSResponder');
+  },
+  clearJSResponder: (): void => {
+    raiseSoftError('clearJSResponder');
+  },
+};
+
+/**
+ * Leave unimplemented: These APIs are deprecated in UIManager. We will eventually remove
+ * them from React Native.
+ */
+const UIManagerJSDeprecatedPlatformAPIs = Platform.select({
+  android: {},
+});
+
+const UIManagerJSPlatformAPIs = PatchedPlatform.select({
+  android: {
+    getConstantsForViewManager: (viewManagerName: string): ?Object => {
+      if (getConstantsForViewManager) {
+        return getConstantsForViewManager(viewManagerName);
+      }
+
+      raiseSoftError('getConstantsForViewManager');
+      return {};
+    },
+    getDefaultEventTypes: (): Array<string> => {
+      if (getDefaultEventTypes) {
+        return getDefaultEventTypesCached();
+      }
+
+      raiseSoftError('getDefaultEventTypes');
+      return [];
+    },
+    setLayoutAnimationEnabledExperimental: (enabled: boolean): void => {
+      /**
+       * Layout animations are always enabled in the New Architecture.
+       * They cannot be turned off.
+       */
+      if (!enabled) {
+        raiseSoftError(
+          'setLayoutAnimationEnabledExperimental(false)',
+          'Layout animations are always enabled in the New Architecture.',
+        );
+      }
+    },
+    sendAccessibilityEvent: (reactTag: number, eventType: number): void => {
+      // Keep this in sync with java:FabricUIManager.sendAccessibilityEventFromJS
+      // and legacySendAccessibilityEvent.android.js
+      const AccessibilityEvent = {
+        TYPE_VIEW_FOCUSED: 0x00000008,
+        TYPE_WINDOW_STATE_CHANGED: 0x00000020,
+        TYPE_VIEW_CLICKED: 0x00000001,
+        TYPE_VIEW_HOVER_ENTER: 0x00000080,
+      };
+
+      let eventName = null;
+      if (eventType === AccessibilityEvent.TYPE_VIEW_FOCUSED) {
+        eventName = 'focus';
+      } else if (eventType === AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
+        eventName = 'windowStateChange';
+      } else if (eventType === AccessibilityEvent.TYPE_VIEW_CLICKED) {
+        eventName = 'click';
+      } else if (eventType === AccessibilityEvent.TYPE_VIEW_HOVER_ENTER) {
+        eventName = 'viewHoverEnter';
+      } else {
+        console.error(
+          `sendAccessibilityEvent() dropping event: Called with unsupported eventType: ${eventType}`,
+        );
+        return;
+      }
+
+      const FabricUIManager = nullthrows(getFabricUIManager());
+      const shadowNode =
+        FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+      if (!shadowNode) {
+        console.error(
+          `sendAccessibilityEvent() dropping event: Cannot find view with tag #${reactTag}`,
+        );
+        return;
+      }
+
+      FabricUIManager.sendAccessibilityEvent(shadowNode, eventName);
+    },
+  },
+  ios: {
+    /**
+     * TODO(T174674274): Implement lazy loading of legacy view managers in the new architecture.
+     *
+     * Leave this unimplemented until we implement lazy loading of legacy modules and view managers in the new architecture.
+     */
+    lazilyLoadView: (name: string): Object => {
+      raiseSoftError('lazilyLoadView');
+      return {};
+    },
+    focus: (reactTag: number): void => {
+      const FabricUIManager = nullthrows(getFabricUIManager());
+      const shadowNode =
+        FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+      if (!shadowNode) {
+        console.error(`focus() noop: Cannot find view with tag #${reactTag}`);
+        return;
+      }
+      FabricUIManager.dispatchCommand(shadowNode, 'focus', []);
+    },
+    blur: (reactTag: number): void => {
+      const FabricUIManager = nullthrows(getFabricUIManager());
+      const shadowNode =
+        FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+      if (!shadowNode) {
+        console.error(`blur() noop: Cannot find view with tag #${reactTag}`);
+        return;
+      }
+      FabricUIManager.dispatchCommand(shadowNode, 'blur', []);
+    },
+  },
+});
+
+const UIManagerJS: UIManagerJSInterface & {[string]: any} = {
+  ...UIManagerJSOverridenAPIs,
+  ...UIManagerJSDeprecatedPlatformAPIs,
+  ...UIManagerJSPlatformAPIs,
+  ...UIManagerJSUnusedInNewArchAPIs,
+  getViewManagerConfig: (viewManagerName: string): mixed => {
+    if (getUIManagerConstants) {
+      const constants = getUIManagerConstantsCached();
+      if (
+        !constants[viewManagerName] &&
+        UIManagerJS.getConstantsForViewManager
+      ) {
+        constants[viewManagerName] =
+          UIManagerJS.getConstantsForViewManager(viewManagerName);
+      }
+      return constants[viewManagerName];
+    } else {
+      raiseSoftError(
+        `getViewManagerConfig('${viewManagerName}')`,
+        `If '${viewManagerName}' has a ViewManager and you want to retrieve its native ViewConfig, please turn on the native ViewConfig interop layer. If you want to see if this component is registered with React Native, please call hasViewManagerConfig('${viewManagerName}') instead.`,
+      );
+      return null;
+    }
+  },
+  hasViewManagerConfig: (viewManagerName: string): boolean => {
+    return unstable_hasComponent(viewManagerName);
+  },
+  getConstants: (): Object => {
+    if (getUIManagerConstants) {
+      return getUIManagerConstantsCached();
+    } else {
+      raiseSoftError('getConstants');
+      return null;
+    }
+  },
+  findSubviewIn: (
+    reactTag: number,
+    point: Array<number>,
+    callback: (
+      nativeViewTag: number,
+      left: number,
+      top: number,
+      width: number,
+      height: number,
+    ) => void,
+  ): void => {
+    const FabricUIManager = nullthrows(getFabricUIManager());
+    const shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+
+    if (!shadowNode) {
+      console.error(
+        `findSubviewIn() noop: Cannot find view with reactTag ${reactTag}`,
+      );
+      return;
+    }
+
+    FabricUIManager.findNodeAtPoint(
+      shadowNode,
+      point[0],
+      point[1],
+      function (internalInstanceHandle) {
+        if (internalInstanceHandle == null) {
+          console.error('findSubviewIn(): Cannot find node at point');
+          return;
+        }
+
+        let instanceHandle: Object = internalInstanceHandle;
+        let node = instanceHandle.stateNode.node;
+
+        if (!node) {
+          console.error('findSubviewIn(): Cannot find node at point');
+          return;
+        }
+
+        let nativeViewTag: number =
+          instanceHandle.stateNode.canonical.nativeTag;
+
+        FabricUIManager.measure(
+          node,
+          function (x, y, width, height, pageX, pageY) {
+            callback(nativeViewTag, pageX, pageY, width, height);
+          },
+        );
+      },
+    );
+  },
+  viewIsDescendantOf: (
+    reactTag: number,
+    ancestorReactTag: number,
+    callback: (result: Array<boolean>) => void,
+  ): void => {
+    const FabricUIManager = nullthrows(getFabricUIManager());
+    const shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+    if (!shadowNode) {
+      console.error(
+        `viewIsDescendantOf() noop: Cannot find view with reactTag ${reactTag}`,
+      );
+      return;
+    }
+
+    const ancestorShadowNode =
+      FabricUIManager.findShadowNodeByTag_DEPRECATED(ancestorReactTag);
+    if (!ancestorShadowNode) {
+      console.error(
+        `viewIsDescendantOf() noop: Cannot find view with ancestorReactTag ${ancestorReactTag}`,
+      );
+      return;
+    }
+
+    // Keep this in sync with ReadOnlyNode.js
+    const DOCUMENT_POSITION_CONTAINED_BY = 16;
+
+    let result = FabricUIManager.compareDocumentPosition(
+      ancestorShadowNode,
+      shadowNode,
+    );
+
+    // eslint-disable-next-line no-bitwise
+    let isAncestor = (result & DOCUMENT_POSITION_CONTAINED_BY) !== 0;
+
+    callback([isAncestor]);
+  },
+  configureNextLayoutAnimation: (
+    config: Object,
+    callback: () => void,
+    errorCallback: (error: Object) => void,
+  ): void => {
+    const FabricUIManager = nullthrows(getFabricUIManager());
+    FabricUIManager.configureNextLayoutAnimation(
+      config,
+      callback,
+      errorCallback,
+    );
+  },
+};
+
+if (getUIManagerConstants) {
+  Object.keys(getUIManagerConstantsCached()).forEach(viewConfigName => {
+    UIManagerJS[viewConfigName] = getUIManagerConstantsCached()[viewConfigName];
+  });
+
+  if (UIManagerJS.getConstants().ViewManagerNames) {
+    UIManagerJS.getConstants().ViewManagerNames.forEach(viewManagerName => {
+      defineLazyObjectProperty(UIManagerJS, viewManagerName, {
+        get: () =>
+          nullthrows(UIManagerJS.getConstantsForViewManager)(viewManagerName),
+      });
+    });
+  }
+}
+
+module.exports = UIManagerJS;

package/Libraries/ReactNative/DisplayMode.js

@@ -0,0 +1,32 @@
+/**
+ * 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 opaque type DisplayModeType = number;
+
+/** DisplayMode should be in sync with the method displayModeToInt from
+ * react/renderer/uimanager/primitives.h. */
+const DisplayMode: {+[string]: DisplayModeType} = Object.freeze({
+  VISIBLE: 1,
+  SUSPENDED: 2,
+  HIDDEN: 3,
+});
+
+export function coerceDisplayMode(value: ?number): DisplayModeType {
+  switch (value) {
+    case DisplayMode.SUSPENDED:
+      return DisplayMode.SUSPENDED;
+    case DisplayMode.HIDDEN:
+      return DisplayMode.HIDDEN;
+    default:
+      return DisplayMode.VISIBLE;
+  }
+}
+
+export default DisplayMode;

package/Libraries/ReactNative/FabricUIManager.js

@@ -0,0 +1,145 @@
+/**
+ * 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';
+
+import type {
+  InternalInstanceHandle,
+  LayoutAnimationConfig,
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+  MeasureOnSuccessCallback,
+  Node,
+} from '../Renderer/shims/ReactNativeTypes';
+import type {RootTag} from '../Types/RootTagTypes';
+
+import defineLazyObjectProperty from '../Utilities/defineLazyObjectProperty';
+
+export type NodeSet = Array<Node>;
+export type NodeProps = {...};
+export interface Spec {
+  +createNode: (
+    reactTag: number,
+    viewName: string,
+    rootTag: RootTag,
+    props: NodeProps,
+    instanceHandle: InternalInstanceHandle,
+  ) => Node;
+  +cloneNode: (node: Node) => Node;
+  +cloneNodeWithNewChildren: (node: Node) => Node;
+  +cloneNodeWithNewProps: (node: Node, newProps: NodeProps) => Node;
+  +cloneNodeWithNewChildrenAndProps: (node: Node, newProps: NodeProps) => Node;
+  +createChildSet: (rootTag: RootTag) => NodeSet;
+  +appendChild: (parentNode: Node, child: Node) => Node;
+  +appendChildToSet: (childSet: NodeSet, child: Node) => void;
+  +completeRoot: (rootTag: RootTag, childSet: NodeSet) => void;
+  +measure: (node: Node, callback: MeasureOnSuccessCallback) => void;
+  +measureInWindow: (
+    node: Node,
+    callback: MeasureInWindowOnSuccessCallback,
+  ) => void;
+  +measureLayout: (
+    node: Node,
+    relativeNode: Node,
+    onFail: () => void,
+    onSuccess: MeasureLayoutOnSuccessCallback,
+  ) => void;
+  +configureNextLayoutAnimation: (
+    config: LayoutAnimationConfig,
+    callback: () => void, // check what is returned here
+    errorCallback: () => void,
+  ) => void;
+  +sendAccessibilityEvent: (node: Node, eventType: string) => void;
+  +findShadowNodeByTag_DEPRECATED: (reactTag: number) => ?Node;
+  +setNativeProps: (node: Node, newProps: NodeProps) => void;
+  +dispatchCommand: (
+    node: Node,
+    commandName: string,
+    args: Array<mixed>,
+  ) => void;
+  +findNodeAtPoint: (
+    node: Node,
+    locationX: number,
+    locationY: number,
+    callback: (instanceHandle: ?InternalInstanceHandle) => void,
+  ) => void;
+  +compareDocumentPosition: (node: Node, otherNode: Node) => number;
+  +getBoundingClientRect: (
+    node: Node,
+    includeTransform: boolean,
+  ) => ?[
+    /* x: */ number,
+    /* y: */ number,
+    /* width: */ number,
+    /* height: */ number,
+  ];
+}
+
+let nativeFabricUIManagerProxy: ?Spec;
+
+// This is a list of all the methods in global.nativeFabricUIManager that we'll
+// cache in JavaScript, as the current implementation of the binding
+// creates a new host function every time methods are accessed.
+const CACHED_PROPERTIES = [
+  'createNode',
+  'cloneNode',
+  'cloneNodeWithNewChildren',
+  'cloneNodeWithNewProps',
+  'cloneNodeWithNewChildrenAndProps',
+  'createChildSet',
+  'appendChild',
+  'appendChildToSet',
+  'completeRoot',
+  'measure',
+  'measureInWindow',
+  'measureLayout',
+  'configureNextLayoutAnimation',
+  'sendAccessibilityEvent',
+  'findShadowNodeByTag_DEPRECATED',
+  'setNativeProps',
+  'dispatchCommand',
+  'compareDocumentPosition',
+  'getBoundingClientRect',
+];
+
+// This is exposed as a getter because apps using the legacy renderer AND
+// Fabric can define the binding lazily. If we evaluated the global and cached
+// it in the module we might be caching an `undefined` value before it is set.
+export function getFabricUIManager(): ?Spec {
+  if (
+    nativeFabricUIManagerProxy == null &&
+    global.nativeFabricUIManager != null
+  ) {
+    nativeFabricUIManagerProxy = createProxyWithCachedProperties(
+      global.nativeFabricUIManager,
+      CACHED_PROPERTIES,
+    );
+  }
+  return nativeFabricUIManagerProxy;
+}
+
+/**
+ *
+ * Returns an object that caches the specified properties the first time they
+ * are accessed, and falls back to the original object for other properties.
+ */
+function createProxyWithCachedProperties(
+  implementation: Spec,
+  propertiesToCache: $ReadOnlyArray<string>,
+): Spec {
+  const proxy = Object.create(implementation);
+  for (const propertyName of propertiesToCache) {
+    defineLazyObjectProperty(proxy, propertyName, {
+      // $FlowExpectedError[prop-missing]
+      get: () => implementation[propertyName],
+    });
+  }
+  return proxy;
+}

package/Libraries/ReactNative/HeadlessJsTaskError.js

@@ -0,0 +1,11 @@
+/**
+ * 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 default class HeadlessJsTaskError extends Error {}

package/Libraries/ReactNative/I18nManager.d.ts

@@ -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
+ */
+
+export interface I18nManagerStatic {
+  getConstants: () => {
+    isRTL: boolean;
+    doLeftAndRightSwapInRTL: boolean;
+    localeIdentifier?: string | null | undefined;
+  };
+  allowRTL: (allowRTL: boolean) => void;
+  forceRTL: (forceRTL: boolean) => void;
+  swapLeftAndRightInRTL: (swapLeftAndRight: boolean) => void;
+  isRTL: boolean;
+  doLeftAndRightSwapInRTL: boolean;
+}
+
+/** https://reactnative.dev/blog/2016/08/19/right-to-left-support-for-react-native-apps */
+export const I18nManager: I18nManagerStatic;
+export type I18nManager = I18nManagerStatic;

package/Libraries/ReactNative/{I18nManager.harmony.js → I18nManager.js}

@@ -8,15 +8,12 @@
  * @format
  */
 
-import NativeI18nManager from 'react-native/Libraries/ReactNative/NativeI18nManager';
+import type {I18nManagerConstants} from './NativeI18nManager';
 
-const i18nConstants: {|
-  doLeftAndRightSwapInRTL: boolean,
-  isRTL: boolean,
-  localeIdentifier?: ?string,
-|} = getI18nManagerConstants();
+import Delegate from './delegates/I18nManagerDelegate';
+import NativeI18nManager from './NativeI18nManager';
 
-function getI18nManagerConstants() {
+function getI18nManagerConstants(): I18nManagerConstants {
   if (NativeI18nManager) {
     const {isRTL, doLeftAndRightSwapInRTL, localeIdentifier} =
       NativeI18nManager.getConstants();
@@ -29,16 +26,10 @@ function getI18nManagerConstants() {
   };
 }
 
+const DELEGATE = new Delegate({constantsCallback: getI18nManagerConstants});
+
 module.exports = {
-  getConstants: (): {|
-    doLeftAndRightSwapInRTL: boolean,
-    isRTL: boolean,
-    localeIdentifier: ?string,
-  |} => {
-    // RNOH patch
-    // return i18nConstants;
-    return Platform.OS === "harmony" ? getI18nManagerConstants() : i18nConstants;
-  },
+  getConstants: DELEGATE.getConstants,
 
   allowRTL: (shouldAllow: boolean) => {
     if (!NativeI18nManager) {
@@ -64,15 +55,10 @@ module.exports = {
     NativeI18nManager.swapLeftAndRightInRTL(flipStyles);
   },
 
-  // RNOH patch
-  get isRTL() {
-    return Platform.OS === "harmony" ? getI18nManagerConstants().isRTL : i18nConstants.isRTL;
+  get isRTL(): boolean {
+    return DELEGATE.isRTL;
   },
-  // isRTL: i18nConstants.isRTL,
-
-  // RNOH patch
-  get doLeftAndRightSwapInRTL() {
-    return Platform.OS === "harmony" ? getI18nManagerConstants().doLeftAndRightSwapInRTL : i18nConstants.doLeftAndRightSwapInRTL;
+  get doLeftAndRightSwapInRTL(): boolean {
+    return DELEGATE.doLeftAndRightSwapInRTL;
   },
-  // doLeftAndRightSwapInRTL: i18nConstants.doLeftAndRightSwapInRTL,
 };