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

package/Libraries/ReactNative/__mocks__/FabricUIManager.js

@@ -0,0 +1,334 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {
+  InternalInstanceHandle,
+  LayoutAnimationConfig,
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+  MeasureOnSuccessCallback,
+  Node,
+} from '../../Renderer/shims/ReactNativeTypes';
+import type {RootTag} from '../../Types/RootTagTypes';
+import type {
+  NodeProps,
+  NodeSet,
+  Spec as FabricUIManager,
+} from '../FabricUIManager';
+
+import {createRootTag} from '../RootTag.js';
+
+export type NodeMock = {
+  children: NodeSet,
+  instanceHandle: InternalInstanceHandle,
+  props: NodeProps,
+  reactTag: number,
+  rootTag: RootTag,
+  viewName: string,
+};
+
+export function fromNode(node: Node): NodeMock {
+  // $FlowExpectedError[incompatible-return]
+  return node;
+}
+
+export function toNode(node: NodeMock): Node {
+  // $FlowExpectedError[incompatible-return]
+  return node;
+}
+
+// Mock of the Native Hooks
+
+const roots: Map<RootTag, NodeSet> = new Map();
+const allocatedTags: Set<number> = new Set();
+
+export function ensureHostNode(node: Node): void {
+  if (node == null || typeof node !== 'object') {
+    throw new Error(
+      `Expected node to be an object. Got ${
+        node === null ? 'null' : typeof node
+      } value`,
+    );
+  }
+
+  if (typeof node.viewName !== 'string') {
+    throw new Error(
+      `Expected node to be a host node. Got object with ${
+        node.viewName === null ? 'null' : typeof node.viewName
+      } viewName`,
+    );
+  }
+}
+
+function getAncestorsInChildSet(
+  node: Node,
+  childSet: NodeSet,
+): ?$ReadOnlyArray<[Node, number]> {
+  const rootNode = toNode({
+    reactTag: 0,
+    rootTag: fromNode(node).rootTag,
+    viewName: 'RootNode',
+    // $FlowExpectedError
+    instanceHandle: null,
+    props: {},
+    children: childSet,
+  });
+
+  let position = 0;
+  for (const child of childSet) {
+    const ancestors = getAncestors(child, node);
+    if (ancestors) {
+      return [[rootNode, position]].concat(ancestors);
+    }
+    position++;
+  }
+
+  return null;
+}
+
+export function getAncestorsInCurrentTree(
+  node: Node,
+): ?$ReadOnlyArray<[Node, number]> {
+  const childSet = roots.get(fromNode(node).rootTag);
+  if (childSet == null) {
+    return null;
+  }
+
+  return getAncestorsInChildSet(node, childSet);
+}
+
+function getAncestors(root: Node, node: Node): ?$ReadOnlyArray<[Node, number]> {
+  if (fromNode(root).reactTag === fromNode(node).reactTag) {
+    return [];
+  }
+
+  let position = 0;
+  for (const child of fromNode(root).children) {
+    const ancestors = getAncestors(child, node);
+    if (ancestors != null) {
+      return [[root, position]].concat(ancestors);
+    }
+    position++;
+  }
+
+  return null;
+}
+
+export function getNodeInChildSet(node: Node, childSet: NodeSet): ?Node {
+  const ancestors = getAncestorsInChildSet(node, childSet);
+  if (ancestors == null) {
+    return null;
+  }
+
+  const [parent, position] = ancestors[ancestors.length - 1];
+  const nodeInCurrentTree = fromNode(parent).children[position];
+  return nodeInCurrentTree;
+}
+
+export function getNodeInCurrentTree(node: Node): ?Node {
+  const childSet = roots.get(fromNode(node).rootTag);
+  if (childSet == null) {
+    return null;
+  }
+
+  return getNodeInChildSet(node, childSet);
+}
+
+interface IFabricUIManagerMock extends FabricUIManager {
+  getRoot(rootTag: RootTag | number): NodeSet;
+  __getInstanceHandleFromNode(node: Node): InternalInstanceHandle;
+  __addCommitHook(commitHook: UIManagerCommitHook): void;
+  __removeCommitHook(commitHook: UIManagerCommitHook): void;
+}
+
+export interface UIManagerCommitHook {
+  shadowTreeWillCommit: (
+    rootTag: RootTag,
+    oldChildSet: ?NodeSet,
+    newChildSet: NodeSet,
+  ) => void;
+}
+
+const commitHooks: Set<UIManagerCommitHook> = new Set();
+
+const FabricUIManagerMock: IFabricUIManagerMock = {
+  createNode: jest.fn(
+    (
+      reactTag: number,
+      viewName: string,
+      rootTag: RootTag,
+      props: NodeProps,
+      instanceHandle: InternalInstanceHandle,
+    ): Node => {
+      if (allocatedTags.has(reactTag)) {
+        throw new Error(`Created two native views with tag ${reactTag}`);
+      }
+
+      allocatedTags.add(reactTag);
+      return toNode({
+        reactTag,
+        rootTag,
+        viewName,
+        instanceHandle,
+        props: props,
+        children: [],
+      });
+    },
+  ),
+
+  cloneNode: jest.fn((node: Node): Node => {
+    return toNode({...fromNode(node)});
+  }),
+
+  cloneNodeWithNewChildren: jest.fn((node: Node): Node => {
+    return toNode({...fromNode(node), children: []});
+  }),
+
+  cloneNodeWithNewProps: jest.fn((node: Node, newProps: NodeProps): Node => {
+    return toNode({
+      ...fromNode(node),
+      props: {
+        ...fromNode(node).props,
+        ...newProps,
+      },
+    });
+  }),
+
+  cloneNodeWithNewChildrenAndProps: jest.fn(
+    (node: Node, newProps: NodeProps): Node => {
+      return toNode({
+        ...fromNode(node),
+        children: [],
+        props: {
+          ...fromNode(node).props,
+          ...newProps,
+        },
+      });
+    },
+  ),
+
+  createChildSet: jest.fn((rootTag: RootTag): NodeSet => {
+    return [];
+  }),
+
+  appendChild: jest.fn((parentNode: Node, child: Node): Node => {
+    // Although the signature returns a Node, React expects this to be mutating.
+    fromNode(parentNode).children.push(child);
+    return parentNode;
+  }),
+
+  appendChildToSet: jest.fn((childSet: NodeSet, child: Node): void => {
+    childSet.push(child);
+  }),
+
+  completeRoot: jest.fn((rootTag: RootTag, childSet: NodeSet): void => {
+    commitHooks.forEach(hook =>
+      hook.shadowTreeWillCommit(rootTag, roots.get(rootTag), childSet),
+    );
+    roots.set(rootTag, childSet);
+  }),
+
+  measure: jest.fn((node: Node, callback: MeasureOnSuccessCallback): void => {
+    ensureHostNode(node);
+
+    callback(10, 10, 100, 100, 0, 0);
+  }),
+
+  measureInWindow: jest.fn(
+    (node: Node, callback: MeasureInWindowOnSuccessCallback): void => {
+      ensureHostNode(node);
+
+      callback(10, 10, 100, 100);
+    },
+  ),
+
+  measureLayout: jest.fn(
+    (
+      node: Node,
+      relativeNode: Node,
+      onFail: () => void,
+      onSuccess: MeasureLayoutOnSuccessCallback,
+    ): void => {
+      ensureHostNode(node);
+      ensureHostNode(relativeNode);
+
+      onSuccess(1, 1, 100, 100);
+    },
+  ),
+
+  configureNextLayoutAnimation: jest.fn(
+    (
+      config: LayoutAnimationConfig,
+      callback: () => void, // check what is returned here
+      errorCallback: () => void,
+    ): void => {},
+  ),
+
+  sendAccessibilityEvent: jest.fn((node: Node, eventType: string): void => {}),
+
+  findShadowNodeByTag_DEPRECATED: jest.fn((reactTag: number): ?Node => {}),
+
+  findNodeAtPoint: jest.fn(
+    (
+      node: Node,
+      locationX: number,
+      locationY: number,
+      callback: (instanceHandle: ?InternalInstanceHandle) => void,
+    ): void => {},
+  ),
+
+  getBoundingClientRect: jest.fn(
+    (
+      node: Node,
+      includeTransform: boolean,
+    ): ?[
+      /* x:*/ number,
+      /* y:*/ number,
+      /* width:*/ number,
+      /* height:*/ number,
+    ] => {},
+  ),
+
+  setNativeProps: jest.fn((node: Node, newProps: NodeProps): void => {}),
+
+  dispatchCommand: jest.fn(
+    (node: Node, commandName: string, args: Array<mixed>): void => {},
+  ),
+
+  compareDocumentPosition: jest.fn((node: Node, otherNode: Node): number => 0),
+
+  getRoot(containerTag: RootTag | number): NodeSet {
+    const tag = createRootTag(containerTag);
+    const root = roots.get(tag);
+    if (!root) {
+      throw new Error('No root found for containerTag ' + Number(tag));
+    }
+    return root;
+  },
+
+  __getInstanceHandleFromNode(node: Node): InternalInstanceHandle {
+    return fromNode(node).instanceHandle;
+  },
+
+  __addCommitHook(commitHook: UIManagerCommitHook): void {
+    commitHooks.add(commitHook);
+  },
+
+  __removeCommitHook(commitHook: UIManagerCommitHook): void {
+    commitHooks.delete(commitHook);
+  },
+};
+
+global.nativeFabricUIManager = FabricUIManagerMock;
+
+export function getFabricUIManager(): ?IFabricUIManagerMock {
+  return FabricUIManagerMock;
+}

package/Libraries/ReactNative/delegates/BaseBridgelessUIManagerDelegate.ts

@@ -0,0 +1,14 @@
+/**
+ * @format
+ */
+
+export type BridgelessUIManagerContext = {};
+
+export abstract class BaseBridgelessUIManagerDelegate {
+  constructor(protected ctx: BridgelessUIManagerContext) {}
+
+  /**
+   * NOTE: delegates should be platform independent, but doing it properly requires more changes and we want to minimize maintenance.
+   */
+  abstract selectAndroidOrIOSImplementation(): 'android' | 'ios';
+}

package/Libraries/ReactNative/delegates/BaseI18nManagerDelegate.ts

@@ -0,0 +1,18 @@
+/**
+ * @format
+ */
+import type {I18nManagerConstants} from '../NativeI18nManager';
+
+export type I18nManagerContext = {
+  constantsCallback: () => I18nManagerConstants;
+};
+
+export abstract class BaseI18nManagerDelegate {
+  constructor(protected ctx: I18nManagerContext) {}
+
+  abstract getConstants: () => I18nManagerConstants;
+
+  abstract isRTL: boolean;
+
+  abstract doLeftAndRightSwapInRTL: boolean;
+}

package/Libraries/ReactNative/delegates/BridgelessUIManagerDelegate.harmony.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2024 Huawei Technologies Co., Ltd.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { BaseBridgelessUIManagerDelegate } from './BaseBridgelessUIManagerDelegate';
+
+export default class BridgelessUIManagerDelegate extends BaseBridgelessUIManagerDelegate {
+  override selectAndroidOrIOSImplementation(): 'android' | 'ios' {
+    return 'android';
+  }
+}

package/Libraries/ReactNative/delegates/BridgelessUIManagerDelegate.ts

@@ -0,0 +1,11 @@
+/**
+ * @format
+ */
+import {BaseBridgelessUIManagerDelegate} from './BaseBridgelessUIManagerDelegate';
+import {UnsupportedByPlatformError} from '../../../delegates/DelegateError';
+
+export default class BridgelessUIManagerDelegate extends BaseBridgelessUIManagerDelegate {
+  override selectAndroidOrIOSImplementation(): 'android' | 'ios' {
+    throw new UnsupportedByPlatformError();
+  }
+}

package/Libraries/ReactNative/delegates/I18nManagerDelegate.harmony.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { BaseI18nManagerDelegate } from './BaseI18nManagerDelegate';
+
+export default class I18nManagerDelegate extends BaseI18nManagerDelegate {
+  override getConstants = () => {
+    return this.ctx.constantsCallback();
+  };
+
+  get isRTL(): boolean {
+    return this.ctx.constantsCallback().isRTL;
+  }
+
+  get doLeftAndRightSwapInRTL(): boolean {
+    return this.ctx.constantsCallback().doLeftAndRightSwapInRTL;
+  }
+}

package/Libraries/ReactNative/delegates/I18nManagerDelegate.ts

@@ -0,0 +1,24 @@
+/**
+ * @format
+ */
+
+import type {I18nManagerConstants} from '../NativeI18nManager';
+import type {I18nManagerContext} from './BaseI18nManagerDelegate';
+import {BaseI18nManagerDelegate} from './BaseI18nManagerDelegate';
+
+export default class I18nManagerDelegate extends BaseI18nManagerDelegate {
+  i18nConstants: I18nManagerConstants;
+  constructor(protected ctx: I18nManagerContext) {
+    super(ctx);
+    this.i18nConstants = ctx.constantsCallback();
+    this.isRTL = this.i18nConstants.isRTL;
+    this.doLeftAndRightSwapInRTL = this.i18nConstants.doLeftAndRightSwapInRTL;
+  }
+
+  getConstants: () => I18nManagerConstants = () => {
+    return this.i18nConstants;
+  };
+
+  isRTL: boolean;
+  doLeftAndRightSwapInRTL: boolean;
+}

package/Libraries/ReactNative/getCachedComponentWithDebugName.js

@@ -0,0 +1,33 @@
+/**
+ * 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 * as React from 'react';
+
+type NoopComponent = component(children: React.Node);
+
+const cache: Map<
+  string, // displayName
+  NoopComponent, // ComponentWithDisplayName
+> = new Map();
+
+export default function getCachedComponentWithDisplayName(
+  displayName: string,
+): NoopComponent {
+  let ComponentWithDisplayName = cache.get(displayName);
+
+  if (!ComponentWithDisplayName) {
+    ComponentWithDisplayName = ({children}: {children: React.Node}) => children;
+    // $FlowFixMe[prop-missing]
+    ComponentWithDisplayName.displayName = displayName;
+    cache.set(displayName, ComponentWithDisplayName);
+  }
+
+  return ComponentWithDisplayName;
+}

package/Libraries/ReactNative/getNativeComponentAttributes.js

@@ -0,0 +1,212 @@
+/**
+ * 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 processBoxShadow from '../StyleSheet/processBoxShadow';
+
+const ReactNativeStyleAttributes = require('../Components/View/ReactNativeStyleAttributes');
+const resolveAssetSource = require('../Image/resolveAssetSource');
+const processBackgroundImage =
+  require('../StyleSheet/processBackgroundImage').default;
+const processColor = require('../StyleSheet/processColor').default;
+const processColorArray = require('../StyleSheet/processColorArray');
+const processFilter = require('../StyleSheet/processFilter').default;
+const insetsDiffer = require('../Utilities/differ/insetsDiffer');
+const matricesDiffer = require('../Utilities/differ/matricesDiffer');
+const pointsDiffer = require('../Utilities/differ/pointsDiffer');
+const sizesDiffer = require('../Utilities/differ/sizesDiffer');
+const UIManager = require('./UIManager');
+const nullthrows = require('nullthrows');
+
+function getNativeComponentAttributes(uiViewClassName: string): any {
+  const viewConfig = UIManager.getViewManagerConfig(uiViewClassName);
+
+  if (viewConfig == null) {
+    return null;
+  }
+
+  // TODO: This seems like a whole lot of runtime initialization for every
+  // native component that can be either avoided or simplified.
+  let {baseModuleName, bubblingEventTypes, directEventTypes} = viewConfig;
+  let nativeProps = viewConfig.NativeProps;
+
+  bubblingEventTypes = bubblingEventTypes ?? {};
+  directEventTypes = directEventTypes ?? {};
+
+  while (baseModuleName) {
+    const baseModule = UIManager.getViewManagerConfig(baseModuleName);
+    if (!baseModule) {
+      baseModuleName = null;
+    } else {
+      bubblingEventTypes = {
+        ...baseModule.bubblingEventTypes,
+        ...bubblingEventTypes,
+      };
+      directEventTypes = {
+        ...baseModule.directEventTypes,
+        ...directEventTypes,
+      };
+      nativeProps = {
+        ...baseModule.NativeProps,
+        ...nativeProps,
+      };
+      baseModuleName = baseModule.baseModuleName;
+    }
+  }
+
+  const validAttributes: {[string]: mixed} = {};
+
+  for (const key in nativeProps) {
+    const typeName = nativeProps[key];
+    const diff = getDifferForType(typeName);
+    const process = getProcessorForType(typeName);
+
+    // If diff or process == null, omit the corresponding property from the Attribute
+    // Why:
+    //  1. Consistency with AttributeType flow type
+    //  2. Consistency with Static View Configs, which omit the null properties
+    validAttributes[key] =
+      diff == null
+        ? process == null
+          ? true
+          : {process}
+        : process == null
+          ? {diff}
+          : {diff, process};
+  }
+
+  // Unfortunately, the current setup declares style properties as top-level
+  // props. This makes it so we allow style properties in the `style` prop.
+  // TODO: Move style properties into a `style` prop and disallow them as
+  // top-level props on the native side.
+  validAttributes.style = ReactNativeStyleAttributes;
+
+  Object.assign(viewConfig, {
+    uiViewClassName,
+    validAttributes,
+    bubblingEventTypes,
+    directEventTypes,
+  });
+
+  attachDefaultEventTypes(viewConfig);
+
+  return viewConfig;
+}
+
+function attachDefaultEventTypes(viewConfig: any) {
+  // This is supported on UIManager platforms (ex: Android),
+  // as lazy view managers are not implemented for all platforms.
+  // See [UIManager] for details on constants and implementations.
+  const constants = UIManager.getConstants();
+  if (constants.ViewManagerNames || constants.LazyViewManagersEnabled) {
+    // Lazy view managers enabled.
+    viewConfig = merge(
+      viewConfig,
+      nullthrows(UIManager.getDefaultEventTypes)(),
+    );
+  } else {
+    viewConfig.bubblingEventTypes = merge(
+      viewConfig.bubblingEventTypes,
+      constants.genericBubblingEventTypes,
+    );
+    viewConfig.directEventTypes = merge(
+      viewConfig.directEventTypes,
+      constants.genericDirectEventTypes,
+    );
+  }
+}
+
+// TODO: Figure out how to avoid all this runtime initialization cost.
+function merge(destination: ?Object, source: ?Object): ?Object {
+  if (!source) {
+    return destination;
+  }
+  if (!destination) {
+    return source;
+  }
+
+  for (const key in source) {
+    if (!source.hasOwnProperty(key)) {
+      continue;
+    }
+
+    let sourceValue = source[key];
+    if (destination.hasOwnProperty(key)) {
+      const destinationValue = destination[key];
+      if (
+        typeof sourceValue === 'object' &&
+        typeof destinationValue === 'object'
+      ) {
+        sourceValue = merge(destinationValue, sourceValue);
+      }
+    }
+    destination[key] = sourceValue;
+  }
+  return destination;
+}
+
+function getDifferForType(
+  typeName: string,
+): ?(prevProp: any, nextProp: any) => boolean {
+  switch (typeName) {
+    // iOS Types
+    case 'CATransform3D':
+      return matricesDiffer;
+    case 'CGPoint':
+      return pointsDiffer;
+    case 'CGSize':
+      return sizesDiffer;
+    case 'UIEdgeInsets':
+      return insetsDiffer;
+    // Android Types
+    case 'Point':
+      return pointsDiffer;
+    case 'EdgeInsets':
+      return insetsDiffer;
+  }
+  return null;
+}
+
+function getProcessorForType(typeName: string): ?(nextProp: any) => any {
+  switch (typeName) {
+    // iOS Types
+    case 'CGColor':
+    case 'UIColor':
+      return processColor;
+    case 'CGColorArray':
+    case 'UIColorArray':
+      return processColorArray;
+    case 'CGImage':
+    case 'UIImage':
+    case 'RCTImageSource':
+      return resolveAssetSource;
+    case 'BoxShadowArray':
+      return processBoxShadow;
+    case 'FilterArray':
+      return processFilter;
+    // Android Types
+    case 'Color':
+      return processColor;
+    case 'ColorArray':
+      return processColorArray;
+    case 'Filter':
+      return processFilter;
+    case 'BackgroundImage':
+      return processBackgroundImage;
+    case 'ImageSource':
+      return resolveAssetSource;
+    case 'BoxShadow':
+      return processBoxShadow;
+  }
+  return null;
+}
+
+module.exports = getNativeComponentAttributes;