@office-iss/react-native-win32 0.0.0-canary.259 → 0.0.0-canary.260

package/src/private/hooks/DebouncedEffectImplementation.js

@@ -0,0 +1,148 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+// $FlowFixMe[untyped-type-import] used as an opaque type
+import type {Task} from 'scheduler';
+// $FlowFixMe[untyped-type-import] used as an opaque type
+import typeof Scheduler from 'scheduler';
+
+import {useCallback, useEffect, useRef} from 'react';
+
+type EffectStatus =
+  // The effect is scheduled but has not yet run. The cleanup function is from
+  // the last execution, if there was one. If the effect gets rescheduled, the
+  // cleanup function must be propagated so that it can run before the updated
+  // effect
+  | {
+      kind: 'scheduled',
+      // $FlowFixMe[value-as-type] Task is opaque
+      task: Task,
+      previousCleanup: null | (() => void),
+    }
+  // The effect has been executed and returned a cleanup function. If it ran
+  // but didn't return a cleanup function, the effect status is set to null.
+  | {
+      cleanup: () => void,
+      kind: 'executed',
+    };
+
+/**
+ * Similar to `useEffect`, this hook schedules a passive effect (@param fn) to
+ * run on mount and whenever the dependency array (@param deps) changes.
+ * However, unlike `useEffect` the effect is debounced so that it runs after
+ * a delay (idle priority callback), reseting if another render occurs. Another
+ * render can occur for example when a layout effect runs and sets state.
+ * Updates triggered in layout effects cause the next render to flush
+ * synchronously and will by default run passive effects first before the
+ * re-render (to flush effects with the original state), and then again after
+ * the re-render (to flush effects with the updated state).
+ *
+ * Instead, this hook will run the effect once per batched render, after it has
+ * committed/painted. The effect is scheduled at idle priority, and if another
+ * render occurs in the meantime it reschedules the effect. Thus the effect
+ * will only run when the component stops re-rendering. When the effect does
+ * run, it is guaranteed to be the latest version of the effect.
+ *
+ * @see https://react.dev/reference/react/useEffect for more on normal passive
+ * effect behavior.
+ */
+export default function useDebouncedEffectImplementation(
+  fn: () => void | (() => void),
+  deps?: ?$ReadOnlyArray<mixed>,
+  // $FlowFixMe[value-as-type] used as an opaque type
+  scheduler: Scheduler,
+): void {
+  const statusRef = useRef<null | EffectStatus>(null);
+
+  const scheduleTask = useCallback(
+    (
+      effectFn: null | (() => void | (() => void)),
+      previousCleanup: null | (() => void),
+    ): void => {
+      const status = statusRef.current;
+      if (status != null && status.kind === 'scheduled') {
+        scheduler.unstable_cancelCallback(status.task);
+      }
+      if (effectFn == null && previousCleanup == null) {
+        statusRef.current = null;
+        return;
+      }
+      const task = scheduler.unstable_scheduleCallback(
+        scheduler.unstable_IdlePriority,
+        () => {
+          if (previousCleanup != null) {
+            previousCleanup();
+          }
+          let cleanup = null;
+          if (effectFn != null) {
+            cleanup = effectFn() ?? null;
+          }
+          if (cleanup == null) {
+            statusRef.current = null;
+          } else {
+            statusRef.current = {
+              kind: 'executed',
+              cleanup,
+            };
+          }
+        },
+      );
+      statusRef.current = {
+        kind: 'scheduled',
+        task,
+        previousCleanup,
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+
+  useEffect(() => {
+    const statusInEffect = statusRef.current;
+    if (statusInEffect == null) {
+      scheduleTask(fn, null);
+    } else if (statusInEffect.kind === 'scheduled') {
+      // Need to cancel & reschedule, maintaining the same cleanup function.
+      scheduleTask(fn, statusInEffect.previousCleanup);
+    } else {
+      // Already executed, we need to schedule a new task and call the cleanup
+      // function from the last execution
+      scheduleTask(fn, statusInEffect.cleanup);
+    }
+
+    return () => {
+      // Rather than immediately run cleanup, we schedule the cleanup task.
+      // If the effect is about to update, then we'll cancel this task and
+      // reschedule with both the cleanup and the new effect function (see above)
+      const statusAtCleanup = statusRef.current;
+      if (statusAtCleanup == null) {
+        // nothing to do, nothing is scheduled and if the task ran already, it
+        // didn't have a cleanup function
+        return;
+      } else if (statusAtCleanup.kind === 'scheduled') {
+        // The task is scheduled but has not yet run. Reschedule just the
+        // cleanup function (the effect function portion may be
+        // overridden momentarily if the effect is about to update, but that's
+        // okay).
+        // Note that if cleanup is null, this will just clear the pending task
+        // and not schedule a new one
+        scheduleTask(null, statusAtCleanup.previousCleanup);
+      } else {
+        // If kind === executed, then we know there is a cleanup function that
+        // still needs to run so schedule it
+        scheduleTask(null, statusAtCleanup.cleanup);
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, deps);
+}

package/src/private/hooks/useDebouncedEffect.js

@@ -0,0 +1,23 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import useDebouncedEffectImplementation from './DebouncedEffectImplementation';
+// $FlowFixMe[untyped-import] used as an opaque type
+import Scheduler from 'scheduler';
+
+export default function useDebouncedEffect(
+  fn: () => void | (() => void),
+  deps?: ?$ReadOnlyArray<mixed>,
+): void {
+  return useDebouncedEffectImplementation(fn, deps, Scheduler);
+}

package/{Libraries/Core → src/private/renderer/errorhandling}/ErrorHandlers.js

@@ -8,11 +8,12 @@
  * @flow strict
  */
 
-'use strict';
+import type {ExtendedError} from '../../../../Libraries/Core/ExtendedError';
 
-import type {ExtendedError} from './ExtendedError';
-
-import {SyntheticError, handleException} from './ExceptionsManager';
+import {
+  SyntheticError,
+  handleException,
+} from '../../../../Libraries/Core/ExceptionsManager';
 
 type ErrorInfo = {
   +componentStack?: ?string,

package/src/private/setup/setUpDOM.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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import DOMRect from '../webapis/dom/geometry/DOMRect';
+import DOMRectReadOnly from '../webapis/dom/geometry/DOMRectReadOnly';
+
+let initialized = false;
+
+export default function setUpDOM() {
+  if (initialized) {
+    return;
+  }
+
+  initialized = true;
+
+  // $FlowExpectedError[cannot-write] The global isn't writable anywhere but here, where we define it
+  global.DOMRect = DOMRect;
+
+  // $FlowExpectedError[cannot-write] The global isn't writable anywhere but here, where we define it
+  global.DOMRectReadOnly = DOMRectReadOnly;
+}

package/src/private/setup/setUpIntersectionObserver.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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import {polyfillGlobal} from '../../../Libraries/Utilities/PolyfillFunctions';
+
+let initialized = false;
+
+export default function setUpIntersectionObserver() {
+  if (initialized) {
+    return;
+  }
+
+  initialized = true;
+
+  polyfillGlobal(
+    'IntersectionObserver',
+    () =>
+      require('../webapis/intersectionobserver/IntersectionObserver').default,
+  );
+}

package/src/private/setup/setUpMutationObserver.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-local
+ * @format
+ */
+
+import {polyfillGlobal} from '../../../Libraries/Utilities/PolyfillFunctions';
+
+let initialized = false;
+
+export default function setUpMutationObserver() {
+  if (initialized) {
+    return;
+  }
+
+  initialized = true;
+
+  polyfillGlobal(
+    'MutationObserver',
+    () => require('../webapis/mutationobserver/MutationObserver').default,
+  );
+}

package/src/private/setup/setUpPerformanceObserver.js

@@ -0,0 +1,64 @@
+/**
+ * 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
+ */
+
+import {polyfillGlobal} from '../../../Libraries/Utilities/PolyfillFunctions';
+
+let initialized = false;
+
+export default function setUpPerformanceObserver() {
+  if (initialized) {
+    return;
+  }
+
+  initialized = true;
+
+  polyfillGlobal(
+    'PerformanceObserver',
+    () =>
+      require('../webapis/performance/PerformanceObserver').PerformanceObserver,
+  );
+
+  polyfillGlobal(
+    'PerformanceObserverEntryList',
+    () =>
+      require('../webapis/performance/PerformanceObserver')
+        .PerformanceObserverEntryList,
+  );
+
+  polyfillGlobal(
+    'PerformanceEntry',
+    () => require('../webapis/performance/PerformanceEntry').PerformanceEntry,
+  );
+
+  polyfillGlobal(
+    'PerformanceMark',
+    () => require('../webapis/performance/UserTiming').PerformanceMark,
+  );
+
+  polyfillGlobal(
+    'PerformanceMeasure',
+    () => require('../webapis/performance/UserTiming').PerformanceMeasure,
+  );
+
+  polyfillGlobal(
+    'PerformanceEventTiming',
+    () => require('../webapis/performance/EventTiming').PerformanceEventTiming,
+  );
+
+  polyfillGlobal(
+    'TaskAttributionTiming',
+    () => require('../webapis/performance/LongTasks').TaskAttributionTiming,
+  );
+
+  polyfillGlobal(
+    'PerformanceLongTaskTiming',
+    () => require('../webapis/performance/LongTasks').PerformanceLongTaskTiming,
+  );
+}

package/src/private/specs/modules/NativeDebuggerSessionObserver.js

@@ -0,0 +1,23 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +hasActiveSession: () => boolean;
+  +subscribe: (callback: (hasActiveSession: boolean) => void) => () => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>(
+  'NativeDebuggerSessionObserverCxx',
+): ?Spec);

package/src/private/webapis/dom/nodes/ReadOnlyNode.js

@@ -304,8 +304,10 @@ function setInstanceHandle(
 export function getShadowNode(node: ReadOnlyNode): ?ShadowNode {
   // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
   // With a static import we can't use these classes for Paper-only variants.
-  const ReactFabric = require('../../../../../Libraries/Renderer/shims/ReactFabric');
-  return ReactFabric.getNodeFromInternalInstanceHandle(getInstanceHandle(node));
+  const RendererProxy = require('../../../../../Libraries/ReactNative/RendererProxy');
+  return RendererProxy.getNodeFromInternalInstanceHandle(
+    getInstanceHandle(node),
+  );
 }
 
 export function getChildNodes(
@@ -349,9 +351,9 @@ export function getPublicInstanceFromInternalInstanceHandle(
 ): ?ReadOnlyNode {
   // Lazy import Fabric here to avoid DOM Node APIs classes from having side-effects.
   // With a static import we can't use these classes for Paper-only variants.
-  const ReactFabric = require('../../../../../Libraries/Renderer/shims/ReactFabric');
+  const RendererProxy = require('../../../../../Libraries/ReactNative/RendererProxy');
   const mixedPublicInstance =
-    ReactFabric.getPublicInstanceFromInternalInstanceHandle(instanceHandle);
+    RendererProxy.getPublicInstanceFromInternalInstanceHandle(instanceHandle);
   // $FlowExpectedError[incompatible-return] React defines public instances as "mixed" because it can't access the definition from React Native.
   return mixedPublicInstance;
 }

package/{Libraries/IntersectionObserver → src/private/webapis/intersectionobserver}/IntersectionObserver.js

@@ -13,7 +13,7 @@
 import type IntersectionObserverEntry from './IntersectionObserverEntry';
 import type {IntersectionObserverId} from './IntersectionObserverManager';
 
-import ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
+import ReactNativeElement from '../dom/nodes/ReactNativeElement';
 import * as IntersectionObserverManager from './IntersectionObserverManager';
 
 export type IntersectionObserverCallback = (

package/{Libraries/IntersectionObserver → src/private/webapis/intersectionobserver}/IntersectionObserverEntry.js

@@ -10,10 +10,10 @@
 
 // flowlint unsafe-getters-setters:off
 
-import type ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
-import type {NativeIntersectionObserverEntry} from './NativeIntersectionObserver';
+import type ReactNativeElement from '../dom/nodes/ReactNativeElement';
+import type {NativeIntersectionObserverEntry} from './specs/NativeIntersectionObserver';
 
-import DOMRectReadOnly from '../../src/private/webapis/dom/geometry/DOMRectReadOnly';
+import DOMRectReadOnly from '../dom/geometry/DOMRectReadOnly';
 
 /**
  * The [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)

package/{Libraries/IntersectionObserver → src/private/webapis/intersectionobserver}/IntersectionObserverManager.js

@@ -18,20 +18,17 @@
  * the notifications together.
  */
 
-import type ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
+import type ReactNativeElement from '../dom/nodes/ReactNativeElement';
 import type IntersectionObserver, {
   IntersectionObserverCallback,
 } from './IntersectionObserver';
 import type IntersectionObserverEntry from './IntersectionObserverEntry';
 
-import {
-  getInstanceHandle,
-  getShadowNode,
-} from '../../src/private/webapis/dom/nodes/ReadOnlyNode';
-import * as Systrace from '../Performance/Systrace';
-import warnOnce from '../Utilities/warnOnce';
+import * as Systrace from '../../../../Libraries/Performance/Systrace';
+import warnOnce from '../../../../Libraries/Utilities/warnOnce';
+import {getInstanceHandle, getShadowNode} from '../dom/nodes/ReadOnlyNode';
 import {createIntersectionObserverEntry} from './IntersectionObserverEntry';
-import NativeIntersectionObserver from './NativeIntersectionObserver';
+import NativeIntersectionObserver from './specs/NativeIntersectionObserver';
 
 export type IntersectionObserverId = number;
 

package/src/private/{specs/modules → webapis/intersectionobserver/specs}/NativeIntersectionObserver.js

@@ -8,9 +8,9 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type NativeIntersectionObserverEntry = {
   intersectionObserverId: number,

package/{Libraries/IntersectionObserver → src/private/webapis/intersectionobserver/specs}/__mocks__/NativeIntersectionObserver.js

@@ -8,16 +8,16 @@
  * @format
  */
 
-import type ReactNativeElement from '../../../src/private/webapis/dom/nodes/ReactNativeElement';
-import type IntersectionObserver from '../IntersectionObserver';
+import type ReactNativeElement from '../../../dom/nodes/ReactNativeElement';
+import type IntersectionObserver from '../../IntersectionObserver';
 import type {
   NativeIntersectionObserverEntry,
   NativeIntersectionObserverObserveOptions,
   Spec,
 } from '../NativeIntersectionObserver';
 
-import {getShadowNode} from '../../../src/private/webapis/dom/nodes/ReadOnlyNode';
-import {getFabricUIManager} from '../../ReactNative/__mocks__/FabricUIManager';
+import {getFabricUIManager} from '../../../../../../Libraries/ReactNative/__mocks__/FabricUIManager';
+import {getShadowNode} from '../../../dom/nodes/ReadOnlyNode';
 import invariant from 'invariant';
 import nullthrows from 'nullthrows';
 

package/{Libraries/MutationObserver → src/private/webapis/mutationobserver}/MutationObserver.js

@@ -13,7 +13,7 @@
 import type {MutationObserverId} from './MutationObserverManager';
 import type MutationRecord from './MutationRecord';
 
-import ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
+import ReactNativeElement from '../dom/nodes/ReactNativeElement';
 import * as MutationObserverManager from './MutationObserverManager';
 
 export type MutationObserverCallback = (

package/{Libraries/MutationObserver → src/private/webapis/mutationobserver}/MutationObserverManager.js

@@ -18,20 +18,20 @@
  * the notifications together.
  */
 
-import type ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
+import type ReactNativeElement from '../dom/nodes/ReactNativeElement';
 import type MutationObserver, {
   MutationObserverCallback,
 } from './MutationObserver';
 import type MutationRecord from './MutationRecord';
 
+import * as Systrace from '../../../../Libraries/Performance/Systrace';
+import warnOnce from '../../../../Libraries/Utilities/warnOnce';
 import {
   getPublicInstanceFromInternalInstanceHandle,
   getShadowNode,
-} from '../../src/private/webapis/dom/nodes/ReadOnlyNode';
-import * as Systrace from '../Performance/Systrace';
-import warnOnce from '../Utilities/warnOnce';
+} from '../dom/nodes/ReadOnlyNode';
 import {createMutationRecord} from './MutationRecord';
-import NativeMutationObserver from './NativeMutationObserver';
+import NativeMutationObserver from './specs/NativeMutationObserver';
 
 export type MutationObserverId = number;
 

package/{Libraries/MutationObserver → src/private/webapis/mutationobserver}/MutationRecord.js

@@ -10,13 +10,11 @@
 
 // flowlint unsafe-getters-setters:off
 
-import type ReactNativeElement from '../../src/private/webapis/dom/nodes/ReactNativeElement';
-import type ReadOnlyNode from '../../src/private/webapis/dom/nodes/ReadOnlyNode';
-import type {NativeMutationRecord} from './NativeMutationObserver';
+import type ReactNativeElement from '../dom/nodes/ReactNativeElement';
+import type ReadOnlyNode from '../dom/nodes/ReadOnlyNode';
+import type {NativeMutationRecord} from './specs/NativeMutationObserver';
 
-import NodeList, {
-  createNodeList,
-} from '../../src/private/webapis/dom/oldstylecollections/NodeList';
+import NodeList, {createNodeList} from '../dom/oldstylecollections/NodeList';
 
 export type MutationType = 'attributes' | 'characterData' | 'childList';
 

package/src/private/{specs/modules → webapis/mutationobserver/specs}/NativeMutationObserver.js

@@ -8,9 +8,9 @@
  * @format
  */
 
-import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
 
-import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export type MutationObserverId = number;
 

package/{Libraries/MutationObserver → src/private/webapis/mutationobserver/specs}/__mocks__/NativeMutationObserver.js

@@ -15,12 +15,12 @@
  * JavaScript as an integration test using only public APIs.
  */
 
-import type {NodeSet} from '../../ReactNative/FabricUIManager';
-import type {RootTag} from '../../ReactNative/RootTag';
+import type {NodeSet} from '../../../../../../Libraries/ReactNative/FabricUIManager';
+import type {RootTag} from '../../../../../../Libraries/ReactNative/RootTag';
 import type {
   InternalInstanceHandle,
   Node,
-} from '../../Renderer/shims/ReactNativeTypes';
+} from '../../../../../../Libraries/Renderer/shims/ReactNativeTypes';
 import type {
   MutationObserverId,
   NativeMutationObserverObserveOptions,
@@ -28,14 +28,14 @@ import type {
   Spec,
 } from '../NativeMutationObserver';
 
-import ReadOnlyNode from '../../../src/private/webapis/dom/nodes/ReadOnlyNode';
 import {
   type NodeMock,
   type UIManagerCommitHook,
   fromNode,
   getFabricUIManager,
   getNodeInChildSet,
-} from '../../ReactNative/__mocks__/FabricUIManager';
+} from '../../../../../../Libraries/ReactNative/__mocks__/FabricUIManager';
+import ReadOnlyNode from '../../../dom/nodes/ReadOnlyNode';
 import invariant from 'invariant';
 import nullthrows from 'nullthrows';