react-native-windows 0.79.5 → 0.80.0-preview.10

package/Libraries/ReactNative/AppRegistryImpl.js

@@ -0,0 +1,316 @@
+/**
+ * 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
+ */
+
+import type {RootTag} from '../Types/RootTagTypes';
+import type {
+  AppConfig,
+  AppParameters,
+  ComponentProvider,
+  ComponentProviderInstrumentationHook,
+  Registry,
+  RootViewStyleProvider,
+  Runnable,
+  Runnables,
+  TaskProvider,
+  WrapperComponentProvider,
+} from './AppRegistry.flow';
+
+import BugReporting from '../BugReporting/BugReporting';
+import createPerformanceLogger from '../Utilities/createPerformanceLogger';
+import infoLog from '../Utilities/infoLog';
+import SceneTracker from '../Utilities/SceneTracker';
+import {coerceDisplayMode} from './DisplayMode';
+import HeadlessJsTaskError from './HeadlessJsTaskError';
+import NativeHeadlessJsTaskSupport from './NativeHeadlessJsTaskSupport';
+import renderApplication from './renderApplication';
+import {unmountComponentAtNodeAndRemoveContainer} from './RendererProxy';
+import invariant from 'invariant';
+
+type TaskCanceller = () => void;
+type TaskCancelProvider = () => TaskCanceller;
+
+const runnables: Runnables = {};
+let runCount = 1;
+const sections: Runnables = {};
+const taskProviders: Map<string, TaskProvider> = new Map();
+const taskCancelProviders: Map<string, TaskCancelProvider> = new Map();
+let componentProviderInstrumentationHook: ComponentProviderInstrumentationHook =
+  (component: ComponentProvider) => component();
+
+let wrapperComponentProvider: ?WrapperComponentProvider;
+let rootViewStyleProvider: ?RootViewStyleProvider;
+
+export function setWrapperComponentProvider(
+  provider: WrapperComponentProvider,
+) {
+  wrapperComponentProvider = provider;
+}
+
+export function setRootViewStyleProvider(provider: RootViewStyleProvider) {
+  rootViewStyleProvider = provider;
+}
+
+export function registerConfig(config: Array<AppConfig>): void {
+  config.forEach(appConfig => {
+    if (appConfig.run) {
+      registerRunnable(appConfig.appKey, appConfig.run);
+    } else {
+      invariant(
+        appConfig.component != null,
+        'AppRegistry.registerConfig(...): Every config is expected to set ' +
+          'either `run` or `component`, but `%s` has neither.',
+        appConfig.appKey,
+      );
+      registerComponent(
+        appConfig.appKey,
+        appConfig.component,
+        appConfig.section,
+      );
+    }
+  });
+}
+
+/**
+ * Registers an app's root component.
+ *
+ * See https://reactnative.dev/docs/appregistry#registercomponent
+ */
+export function registerComponent(
+  appKey: string,
+  componentProvider: ComponentProvider,
+  section?: boolean,
+): string {
+  const scopedPerformanceLogger = createPerformanceLogger();
+  runnables[appKey] = (appParameters, displayMode) => {
+    renderApplication(
+      componentProviderInstrumentationHook(
+        componentProvider,
+        scopedPerformanceLogger,
+      ),
+      appParameters.initialProps,
+      appParameters.rootTag,
+      wrapperComponentProvider && wrapperComponentProvider(appParameters),
+      rootViewStyleProvider && rootViewStyleProvider(appParameters),
+      appParameters.fabric,
+      scopedPerformanceLogger,
+      appKey === 'LogBox', // is logbox
+      appKey,
+      displayMode,
+    );
+  };
+  if (section) {
+    sections[appKey] = runnables[appKey];
+  }
+  return appKey;
+}
+
+export function registerRunnable(appKey: string, run: Runnable): string {
+  runnables[appKey] = run;
+  return appKey;
+}
+
+export function registerSection(
+  appKey: string,
+  component: ComponentProvider,
+): void {
+  registerComponent(appKey, component, true);
+}
+
+export function getAppKeys(): $ReadOnlyArray<string> {
+  return Object.keys(runnables);
+}
+
+export function getSectionKeys(): $ReadOnlyArray<string> {
+  return Object.keys(sections);
+}
+
+export function getSections(): Runnables {
+  return {
+    ...sections,
+  };
+}
+
+export function getRunnable(appKey: string): ?Runnable {
+  return runnables[appKey];
+}
+
+export function getRegistry(): Registry {
+  return {
+    sections: getSectionKeys(),
+    runnables: {...runnables},
+  };
+}
+
+export function setComponentProviderInstrumentationHook(
+  hook: ComponentProviderInstrumentationHook,
+) {
+  componentProviderInstrumentationHook = hook;
+}
+
+/**
+ * Loads the JavaScript bundle and runs the app.
+ *
+ * See https://reactnative.dev/docs/appregistry#runapplication
+ */
+export function runApplication(
+  appKey: string,
+  appParameters: AppParameters,
+  displayMode?: number,
+): void {
+  if (appKey !== 'LogBox') {
+    const logParams = __DEV__ ? ` with ${JSON.stringify(appParameters)}` : '';
+    const msg = `Running "${appKey}"${logParams}`;
+    infoLog(msg);
+    BugReporting.addSource(
+      'AppRegistry.runApplication' + runCount++,
+      () => msg,
+    );
+  }
+  invariant(
+    runnables[appKey],
+    `"${appKey}" has not been registered. This can happen if:\n` +
+      '* Metro (the local dev server) is run from the wrong folder. ' +
+      'Check if Metro is running, stop it and restart it in the current project.\n' +
+      "* A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.",
+  );
+
+  SceneTracker.setActiveScene({name: appKey});
+  runnables[appKey](appParameters, coerceDisplayMode(displayMode));
+}
+
+/**
+ * Update initial props for a surface that's already rendered
+ */
+export function setSurfaceProps(
+  appKey: string,
+  appParameters: Object,
+  displayMode?: number,
+): void {
+  if (appKey !== 'LogBox') {
+    const msg =
+      'Updating props for Surface "' +
+      appKey +
+      '" with ' +
+      JSON.stringify(appParameters);
+    infoLog(msg);
+    BugReporting.addSource(
+      'AppRegistry.setSurfaceProps' + runCount++,
+      () => msg,
+    );
+  }
+  invariant(
+    runnables[appKey],
+    `"${appKey}" has not been registered. This can happen if:\n` +
+      '* Metro (the local dev server) is run from the wrong folder. ' +
+      'Check if Metro is running, stop it and restart it in the current project.\n' +
+      "* A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.",
+  );
+
+  runnables[appKey](appParameters, coerceDisplayMode(displayMode));
+}
+
+/**
+ * Stops an application when a view should be destroyed.
+ *
+ * See https://reactnative.dev/docs/appregistry#unmountapplicationcomponentatroottag
+ */
+export function unmountApplicationComponentAtRootTag(rootTag: RootTag): void {
+  unmountComponentAtNodeAndRemoveContainer(rootTag);
+}
+
+/**
+ * Register a headless task. A headless task is a bit of code that runs without a UI.
+ *
+ * See https://reactnative.dev/docs/appregistry#registerheadlesstask
+ */
+export function registerHeadlessTask(
+  taskKey: string,
+  taskProvider: TaskProvider,
+): void {
+  // $FlowFixMe[object-this-reference]
+  registerCancellableHeadlessTask(taskKey, taskProvider, () => () => {
+    /* Cancel is no-op */
+  });
+}
+
+/**
+ * Register a cancellable headless task. A headless task is a bit of code that runs without a UI.
+ *
+ * See https://reactnative.dev/docs/appregistry#registercancellableheadlesstask
+ */
+export function registerCancellableHeadlessTask(
+  taskKey: string,
+  taskProvider: TaskProvider,
+  taskCancelProvider: TaskCancelProvider,
+): void {
+  if (taskProviders.has(taskKey)) {
+    console.warn(
+      `registerHeadlessTask or registerCancellableHeadlessTask called multiple times for same key '${taskKey}'`,
+    );
+  }
+  taskProviders.set(taskKey, taskProvider);
+  taskCancelProviders.set(taskKey, taskCancelProvider);
+}
+
+/**
+ * Only called from native code. Starts a headless task.
+ *
+ * See https://reactnative.dev/docs/appregistry#startheadlesstask
+ */
+export function startHeadlessTask(
+  taskId: number,
+  taskKey: string,
+  data: any,
+): void {
+  const taskProvider = taskProviders.get(taskKey);
+  if (!taskProvider) {
+    console.warn(`No task registered for key ${taskKey}`);
+    if (NativeHeadlessJsTaskSupport) {
+      NativeHeadlessJsTaskSupport.notifyTaskFinished(taskId);
+    }
+    return;
+  }
+  taskProvider()(data)
+    .then(() => {
+      if (NativeHeadlessJsTaskSupport) {
+        NativeHeadlessJsTaskSupport.notifyTaskFinished(taskId);
+      }
+    })
+    .catch(reason => {
+      console.error(reason);
+
+      if (
+        NativeHeadlessJsTaskSupport &&
+        reason instanceof HeadlessJsTaskError
+      ) {
+        // $FlowFixMe[unused-promise]
+        NativeHeadlessJsTaskSupport.notifyTaskRetry(taskId).then(
+          retryPosted => {
+            if (!retryPosted) {
+              NativeHeadlessJsTaskSupport.notifyTaskFinished(taskId);
+            }
+          },
+        );
+      }
+    });
+}
+
+/**
+ * Only called from native code. Cancels a headless task.
+ *
+ * See https://reactnative.dev/docs/appregistry#cancelheadlesstask
+ */
+export function cancelHeadlessTask(taskId: number, taskKey: string): void {
+  const taskCancelProvider = taskCancelProviders.get(taskKey);
+  if (!taskCancelProvider) {
+    throw new Error(`No task canceller registered for key '${taskKey}'`);
+  }
+  taskCancelProvider()();
+}

package/Libraries/ReactNative/FabricUIManager.js

@@ -92,6 +92,11 @@ export interface Spec {
     /* width: */ number,
     /* height: */ number,
   ];
+  +unstable_DefaultEventPriority: number;
+  +unstable_DiscreteEventPriority: number;
+  +unstable_ContinuousEventPriority: number;
+  +unstable_IdleEventPriority: number;
+  +unstable_getCurrentEventPriority: () => number;
 }
 
 let nativeFabricUIManagerProxy: ?Spec;
@@ -119,6 +124,11 @@ const CACHED_PROPERTIES = [
   'dispatchCommand',
   'compareDocumentPosition',
   'getBoundingClientRect',
+  'unstable_DefaultEventPriority',
+  'unstable_DiscreteEventPriority',
+  'unstable_ContinuousEventPriority',
+  'unstable_IdleEventPriority',
+  'unstable_getCurrentEventPriority',
 ];
 
 // This is exposed as a getter because apps using the legacy renderer AND

package/Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricHostComponent.js

@@ -10,10 +10,10 @@
 
 import type {
   HostInstance,
-  LegacyHostInstanceMethods,
   MeasureInWindowOnSuccessCallback,
   MeasureLayoutOnSuccessCallback,
   MeasureOnSuccessCallback,
+  NativeMethods,
 } from '../../../src/private/types/HostInstance';
 import type {
   InternalInstanceHandle,
@@ -40,9 +40,7 @@ const noop = () => {};
 /**
  * This is used for refs on host components.
  */
-export default class ReactFabricHostComponent
-  implements LegacyHostInstanceMethods
-{
+export default class ReactFabricHostComponent implements NativeMethods {
   // These need to be accessible from `ReactFabricPublicInstanceUtils`.
   __nativeTag: number;
   __internalInstanceHandle: InternalInstanceHandle;

package/Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance.js

@@ -71,10 +71,7 @@ function getReadOnlyTextClass(): Class<ReadOnlyTextT> {
 }
 
 export function createPublicRootInstance(rootTag: RootTag): PublicRootInstance {
-  if (
-    ReactNativeFeatureFlags.enableAccessToHostTreeInFabric() &&
-    ReactNativeFeatureFlags.enableDOMDocumentAPI()
-  ) {
+  if (ReactNativeFeatureFlags.enableAccessToHostTreeInFabric()) {
     const ReactNativeDocumentModule = getReactNativeDocumentModule();
 
     // $FlowExpectedError[incompatible-return]

package/Libraries/ReactNative/RendererImplementation.js

@@ -13,7 +13,6 @@ import type {
   InternalInstanceHandle,
   Node,
 } from '../Renderer/shims/ReactNativeTypes';
-import type {ElementRef, ElementType} from 'react';
 
 import {
   onCaughtError,
@@ -21,6 +20,8 @@ import {
   onUncaughtError,
 } from '../../src/private/renderer/errorhandling/ErrorHandlers';
 import {type RootTag} from './RootTag';
+import * as React from 'react';
+
 export function renderElement({
   element,
   rootTag,
@@ -58,18 +59,22 @@ export function renderElement({
   }
 }
 
-export function findHostInstance_DEPRECATED<TElementType: ElementType>(
-  componentOrHandle: ?(ElementRef<TElementType> | number),
+export function findHostInstance_DEPRECATED<TElementType: React.ElementType>(
+  // $FlowFixMe[incompatible-call]
+  componentOrHandle: ?(React.ElementRef<TElementType> | number),
 ): ?HostInstance {
   return require('../Renderer/shims/ReactNative').default.findHostInstance_DEPRECATED(
+    // $FlowFixMe[incompatible-call]
     componentOrHandle,
   );
 }
 
-export function findNodeHandle<TElementType: ElementType>(
-  componentOrHandle: ?(ElementRef<TElementType> | number),
+export function findNodeHandle<TElementType: React.ElementType>(
+  // $FlowFixMe[incompatible-call]
+  componentOrHandle: ?(React.ElementRef<TElementType> | number),
 ): ?number {
   return require('../Renderer/shims/ReactNative').default.findNodeHandle(
+    // $FlowFixMe[incompatible-call]
     componentOrHandle,
   );
 }

package/Libraries/ReactNative/getNativeComponentAttributes.js

@@ -90,6 +90,7 @@ function getNativeComponentAttributes(uiViewClassName: string): any {
   // top-level props on the native side.
   validAttributes.style = ReactNativeStyleAttributes;
 
+  // $FlowFixMe[unsafe-object-assign]
   Object.assign(viewConfig, {
     uiViewClassName,
     validAttributes,

package/Libraries/ReactNative/renderApplication.js

@@ -13,6 +13,7 @@ import type {IPerformanceLogger} from '../Utilities/createPerformanceLogger';
 
 import GlobalPerformanceLogger from '../Utilities/GlobalPerformanceLogger';
 import PerformanceLoggerContext from '../Utilities/PerformanceLoggerContext';
+import warnOnce from '../Utilities/warnOnce';
 import AppContainer from './AppContainer';
 import DisplayMode, {type DisplayModeType} from './DisplayMode';
 import getCachedComponentWithDebugName from './getCachedComponentWithDebugName';
@@ -104,5 +105,13 @@ export default function renderApplication<Props: Object>(
     useFabric: Boolean(fabric),
     useConcurrentRoot,
   });
+
+  const newArchitecture = !!fabric;
+  if (!newArchitecture) {
+    warnOnce(
+      '[OSS][OldArchDeprecatedWarning]',
+      'The app is running using the Legacy Architecture. The Legacy Architecture is deprecated and will be removed in a future version of React Native. Please consider migrating to the New Architecture. For more information, please see https://reactnative.dev/blog/2024/10/23/the-new-architecture-is-here',
+    );
+  }
   performanceLogger.stopTimespan('renderApplication_React_render');
 }

package/Libraries/ReactPrivate/ReactNativePrivateInterface.js

@@ -8,6 +8,7 @@
  * @flow strict-local
  */
 
+import typeof CustomEvent from '../../src/private/webapis/dom/events/CustomEvent';
 import typeof BatchedBridge from '../BatchedBridge/BatchedBridge';
 import typeof legacySendAccessibilityEvent from '../Components/AccessibilityInfo/legacySendAccessibilityEvent';
 import typeof TextInputState from '../Components/TextInput/TextInputState';
@@ -15,7 +16,6 @@ import typeof ExceptionsManager from '../Core/ExceptionsManager';
 import typeof RawEventEmitter from '../Core/RawEventEmitter';
 import typeof ReactFiberErrorDialog from '../Core/ReactFiberErrorDialog';
 import typeof RCTEventEmitter from '../EventEmitter/RCTEventEmitter';
-import typeof CustomEvent from '../Events/CustomEvent';
 import typeof {
   createPublicInstance,
   createPublicRootInstance,
@@ -41,7 +41,7 @@ export type {
   HostInstance as PublicInstance,
 
   // These types are only necessary for Paper
-  LegacyHostInstanceMethods as LegacyPublicInstance,
+  NativeMethods as LegacyPublicInstance,
   MeasureOnSuccessCallback,
   MeasureInWindowOnSuccessCallback,
   MeasureLayoutOnSuccessCallback,
@@ -99,7 +99,7 @@ module.exports = {
     return require('../Core/RawEventEmitter').default;
   },
   get CustomEvent(): CustomEvent {
-    return require('../Events/CustomEvent').default;
+    return require('../../src/private/webapis/dom/events/CustomEvent').default;
   },
   get createAttributePayload(): createAttributePayload {
     return require('../ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload')

package/Libraries/ReactPrivate/ReactNativePrivateInterface.js.flow

@@ -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-local
+ */
+
+import typeof {createPublicTextInstance} from '../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
+
+export type {
+  HostInstance as PublicInstance,
+
+  // These types are only necessary for Paper
+  NativeMethods as LegacyPublicInstance,
+  MeasureOnSuccessCallback,
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+} from '../../src/private/types/HostInstance';
+
+export type {PublicRootInstance} from '../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
+export type PublicTextInstance = ReturnType<createPublicTextInstance>;
+
+export {default as BatchedBridge} from '../BatchedBridge/BatchedBridge';
+export {default as ExceptionsManager} from '../Core/ExceptionsManager';
+export {default as Platform} from '../Utilities/Platform';
+export {default as RCTEventEmitter} from '../EventEmitter/RCTEventEmitter';
+export * as ReactNativeViewConfigRegistry from '../Renderer/shims/ReactNativeViewConfigRegistry';
+export {default as TextInputState} from '../Components/TextInput/TextInputState';
+export {default as UIManager} from '../ReactNative/UIManager';
+export {default as deepDiffer} from '../Utilities/differ/deepDiffer';
+export {default as deepFreezeAndThrowOnMutationInDev} from '../Utilities/deepFreezeAndThrowOnMutationInDev';
+export {default as flattenStyle} from '../StyleSheet/flattenStyle';
+export {default as ReactFiberErrorDialog} from '../Core/ReactFiberErrorDialog';
+export {default as legacySendAccessibilityEvent} from '../Components/AccessibilityInfo/legacySendAccessibilityEvent';
+export {default as RawEventEmitter} from '../Core/RawEventEmitter';
+export {default as CustomEvent} from '../../src/private/webapis/dom/events/CustomEvent';
+export {
+  create as createAttributePayload,
+  diff as diffAttributePayloads,
+} from '../ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload';
+export {
+  createPublicRootInstance,
+  createPublicInstance,
+  createPublicTextInstance,
+  getNativeTagFromPublicInstance,
+  getNodeFromPublicInstance,
+  getInternalInstanceHandleFromPublicInstance,
+} from '../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';