@office-iss/react-native-win32 0.70.2 → 0.71.0-preview.1

package/Libraries/__flowtests__/ReactNativeTypes-flowtest.js

@@ -8,9 +8,10 @@
  * @format
  */
 
-import * as React from 'react';
 import type {HostComponent} from '../Renderer/shims/ReactNativeTypes';
 
+import * as React from 'react';
+
 function takesHostComponentInstance(
   instance: React.ElementRef<HostComponent<mixed>> | null,
 ): void {}

package/Libraries/__tests__/ButtonWin32-test.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const React = require('react');
+const ReactTestRenderer = require('react-test-renderer');
+
+const {ButtonWin32} = require('../Components/Button/ButtonWin32');
+
+describe('ButtonWin32', () => {
+  it('renders native component', () => {
+    const component = ReactTestRenderer.create(
+      <ButtonWin32/>
+    );
+    expect(component).toMatchSnapshot();
+  });
+});

package/Libraries/platform-types.d.ts

@@ -0,0 +1,25 @@
+/*
+ * This file contains the win32 extra types, which are not part of core.
+ *
+ * NOTE: Concrete classes, objects etc that actually need to be exported from the package,
+*        need to also be added to index.win32.js
+*/
+
+export type { 
+      AccessibilityActionInfo,
+      AccessibilityActionName,
+      AccessibilityState
+} from './Components/View/ViewWin32.Props';
+export * from './Components/View/ViewWin32.Props';
+export * from './Components/View/ViewWin32';
+export * from './Components/Text/TextWin32.Props';
+export * from './Components/Text/TextWin32';
+export * from './Components/Button/ButtonWin32.Props';
+export * from './Components/Button/ButtonWin32';
+export * from './StyleSheet/PlatformColorValueTypesWin32';
+export * from './Components/Touchable/TouchableWin32.Props';
+export * from './Components/Touchable/TouchableWin32.Types';
+export * from './Components/Touchable/TouchableWin32';
+export * from './PersonaCoin/PersonaCoin';
+export * from './PersonaCoin/PersonaCoinTypes';
+export * from './Utilities/FocusManager.win32';

package/Libraries/vendor/core/ErrorUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+
+type ErrorHandlerCallback = (error: any, isFatal?: boolean) => void;
+
+export interface ErrorUtils {
+  setGlobalHandler: (callback: ErrorHandlerCallback) => void;
+  getGlobalHandler: () => ErrorHandlerCallback;
+}

package/Libraries/vendor/emitter/EventEmitter.d.ts

@@ -0,0 +1,164 @@
+/**
+ * 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
+ */
+
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+interface EventSubscription {
+  eventType: string;
+  key: number;
+  subscriber: EventSubscriptionVendor;
+
+  /**
+   * @param subscriber the subscriber that controls
+   *   this subscription.
+   */
+  new (subscriber: EventSubscriptionVendor): EventSubscription;
+
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+  remove(): void;
+}
+
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+declare class EventSubscriptionVendor {
+  constructor();
+
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   */
+  addSubscription(
+    eventType: string,
+    subscription: EventSubscription,
+  ): EventSubscription;
+
+  /**
+   * Removes a bulk set of the subscriptions.
+   *
+   * @param eventType - Optional name of the event type whose
+   *   registered supscriptions to remove, if null remove all subscriptions.
+   */
+  removeAllSubscriptions(eventType?: string): void;
+
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   */
+  removeSubscription(subscription: any): void;
+
+  /**
+   * Returns the array of subscriptions that are currently registered for the
+   * given event type.
+   *
+   * Note: This array can be potentially sparse as subscriptions are deleted
+   * from it when they are removed.
+   *
+   */
+  getSubscriptionsForType(eventType: string): EventSubscription[];
+}
+
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+interface EmitterSubscription extends EventSubscription {
+  emitter: EventEmitter;
+  listener: () => any;
+  context: any;
+
+  /**
+   * @param emitter - The event emitter that registered this
+   *   subscription
+   * @param subscriber - The subscriber that controls
+   *   this subscription
+   * @param listener - Function to invoke when the specified event is
+   *   emitted
+   * @param context - Optional context object to use when invoking the
+   *   listener
+   */
+  new (
+    emitter: EventEmitter,
+    subscriber: EventSubscriptionVendor,
+    listener: () => any,
+    context: any,
+  ): EmitterSubscription;
+
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+  remove(): void;
+}
+
+export declare class EventEmitter {
+  /**
+   *
+   * @param subscriber - Optional subscriber instance
+   *   to use. If omitted, a new subscriber will be created for the emitter.
+   */
+  constructor(subscriber?: EventSubscriptionVendor | null);
+
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * @param eventType - Name of the event to listen to
+   * @param listener - Function to invoke when the specified event is
+   *   emitted
+   * @param context - Optional context object to use when invoking the
+   *   listener
+   */
+  addListener(
+    eventType: string,
+    listener: (...args: any[]) => any,
+    context?: any,
+  ): EmitterSubscription;
+
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+  removeAllListeners(eventType?: string): void;
+
+  /**
+   * Returns the number of listeners that are currently registered for the given
+   * event.
+   *
+   * @param eventType - Name of the event to query
+   */
+  listenerCount(eventType: string): number;
+
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param eventType - Name of the event to emit
+   * @param Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+  emit(eventType: string, ...params: any[]): void;
+}

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: "@rnw-scripts/babel-react-native-config",
+};

package/flow/jest.js

@@ -810,7 +810,7 @@ type JestObjectType = {
    * Returns a new, unused mock function. Optionally takes a mock
    * implementation.
    */
-  fn<TArguments: $ReadOnlyArray<mixed>, TReturn>(
+  fn<TArguments: $ReadOnlyArray<mixed> = $ReadOnlyArray<any>, TReturn = any>(
     implementation?: (...args: TArguments) => TReturn,
   ): JestMockFn<TArguments, TReturn>,
   /**
@@ -900,7 +900,7 @@ type JestObjectType = {
    * (setTimeout, setInterval, clearTimeout, clearInterval, nextTick,
    * setImmediate and clearImmediate).
    */
-  useFakeTimers(): JestObjectType,
+  useFakeTimers(type?: 'legacy' | 'modern'): JestObjectType,
   /**
    * Instructs Jest to use the real versions of the standard timer functions.
    */

package/flow-typed/npm/{react-dom_v16.x.x.js → react-dom_v17.x.x.js}

@@ -1,32 +1,31 @@
-/**
- * react-dom v16.x.x libdefs from flow-typed
- *
- * @noformat
- */
+// flow-typed signature: e556c06e721548417501c08b01fec911
+// flow-typed version: ad3adf2de8/react-dom_v17.x.x/flow_>=v0.127.x
+
 declare module 'react-dom' {
+  declare var version: string;
+
   declare function findDOMNode(
-    componentOrElement: Element | ?React$Component<any, any>,
+    componentOrElement: Element | ?React$Component<any, any>
   ): null | Element | Text;
 
   declare function render<ElementType: React$ElementType>(
     element: React$Element<ElementType>,
     container: Element,
-    callback?: () => void,
+    callback?: () => void
   ): React$ElementRef<ElementType>;
 
   declare function hydrate<ElementType: React$ElementType>(
     element: React$Element<ElementType>,
     container: Element,
-    callback?: () => void,
+    callback?: () => void
   ): React$ElementRef<ElementType>;
 
   declare function createPortal(
     node: React$Node,
-    container: Element,
+    container: Element
   ): React$Portal;
 
   declare function unmountComponentAtNode(container: any): boolean;
-  declare var version: string;
 
   declare function unstable_batchedUpdates<A, B, C, D, E>(
     callback: (a: A, b: B, c: C, d: D, e: E) => mixed,
@@ -34,79 +33,107 @@ declare module 'react-dom' {
     b: B,
     c: C,
     d: D,
-    e: E,
+    e: E
   ): void;
+
   declare function unstable_renderSubtreeIntoContainer<
-    ElementType: React$ElementType,
+    ElementType: React$ElementType
   >(
     parentComponent: React$Component<any, any>,
     nextElement: React$Element<ElementType>,
     container: any,
-    callback?: () => void,
+    callback?: () => void
   ): React$ElementRef<ElementType>;
 }
 
 declare module 'react-dom/server' {
+  declare var version: string;
+
   declare function renderToString(element: React$Node): string;
+
   declare function renderToStaticMarkup(element: React$Node): string;
+
   declare function renderToNodeStream(element: React$Node): stream$Readable;
+
   declare function renderToStaticNodeStream(
-    element: React$Node,
+    element: React$Node
   ): stream$Readable;
-  declare var version: string;
 }
 
-type Thenable = { then(resolve: () => mixed, reject?: () => mixed): mixed, ... };
-
 declare module 'react-dom/test-utils' {
-  declare var Simulate: { [eventName: string]: (element: Element, eventData?: Object) => void, ... };
+  declare interface Thenable {
+    then(resolve: () => mixed, reject?: () => mixed): mixed,
+  }
+
+  declare var Simulate: {
+    [eventName: string]: (
+      element: Element,
+      eventData?: { [key: string]: mixed, ... }
+    ) => void,
+    ...
+  };
+
   declare function renderIntoDocument(
-    instance: React$Element<any>,
+    instance: React$Element<any>
   ): React$Component<any, any>;
+
   declare function mockComponent(
     componentClass: React$ElementType,
-    mockTagName?: string,
-  ): Object;
+    mockTagName?: string
+  ): { [key: string]: mixed, ... };
+
   declare function isElement(element: React$Element<any>): boolean;
+
   declare function isElementOfType(
     element: React$Element<any>,
-    componentClass: React$ElementType,
+    componentClass: React$ElementType
   ): boolean;
+
   declare function isDOMComponent(instance: any): boolean;
+
   declare function isCompositeComponent(
-    instance: React$Component<any, any>,
+    instance: React$Component<any, any>
   ): boolean;
+
   declare function isCompositeComponentWithType(
     instance: React$Component<any, any>,
-    componentClass: React$ElementType,
+    componentClass: React$ElementType
   ): boolean;
+
   declare function findAllInRenderedTree(
     tree: React$Component<any, any>,
-    test: (child: React$Component<any, any>) => boolean,
+    test: (child: React$Component<any, any>) => boolean
   ): Array<React$Component<any, any>>;
+
   declare function scryRenderedDOMComponentsWithClass(
     tree: React$Component<any, any>,
-    className: string,
+    className: string
   ): Array<Element>;
+
   declare function findRenderedDOMComponentWithClass(
     tree: React$Component<any, any>,
-    className: string,
+    className: string
   ): ?Element;
+
   declare function scryRenderedDOMComponentsWithTag(
     tree: React$Component<any, any>,
-    tagName: string,
+    tagName: string
   ): Array<Element>;
+
   declare function findRenderedDOMComponentWithTag(
     tree: React$Component<any, any>,
-    tagName: string,
+    tagName: string
   ): ?Element;
+
   declare function scryRenderedComponentsWithType(
     tree: React$Component<any, any>,
-    componentClass: React$ElementType,
+    componentClass: React$ElementType
   ): Array<React$Component<any, any>>;
+
   declare function findRenderedComponentWithType(
     tree: React$Component<any, any>,
-    componentClass: React$ElementType,
+    componentClass: React$ElementType
   ): ?React$Component<any, any>;
+
   declare function act(callback: () => void | Thenable): Thenable;
 }