@office-iss/react-native-win32 0.71.4 → 0.72.0-preview.1

package/Libraries/Components/Slider/SliderNativeComponent.js

@@ -1,56 +0,0 @@
-/**
- * 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 type {ImageSource} from '../../Image/ImageSource';
-import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
-import type {ColorValue} from '../../StyleSheet/StyleSheet';
-import type {
-  BubblingEventHandler,
-  DirectEventHandler,
-  Double,
-  WithDefault,
-} from '../../Types/CodegenTypes';
-import type {ViewProps} from '../View/ViewPropTypes';
-
-import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
-
-type Event = $ReadOnly<{|
-  value: Double,
-  fromUser?: boolean,
-|}>;
-
-type NativeProps = $ReadOnly<{|
-  ...ViewProps,
-
-  // Props
-  disabled?: WithDefault<boolean, false>,
-  enabled?: WithDefault<boolean, true>,
-  maximumTrackImage?: ?ImageSource,
-  maximumTrackTintColor?: ?ColorValue,
-  maximumValue?: WithDefault<Double, 1>,
-  minimumTrackImage?: ?ImageSource,
-  minimumTrackTintColor?: ?ColorValue,
-  minimumValue?: WithDefault<Double, 0>,
-  step?: WithDefault<Double, 0>,
-  testID?: WithDefault<string, ''>,
-  thumbImage?: ?ImageSource,
-  thumbTintColor?: ?ColorValue,
-  trackImage?: ?ImageSource,
-  value?: WithDefault<Double, 0>,
-
-  // Events
-  onValueChange?: ?BubblingEventHandler<Event>,
-  onSlidingComplete?: ?DirectEventHandler<Event>,
-|}>;
-
-export default (codegenNativeComponent<NativeProps>('Slider', {
-  interfaceOnly: true,
-  paperComponentName: 'RCTSlider',
-}): HostComponent<NativeProps>);

package/Libraries/Components/TextInput/Win32TextInputNativeComponent.js

@@ -1,23 +0,0 @@
-/**
- * @flow
- * @format
- */
-
-import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
-
-import requireNativeComponent from '../../ReactNative/requireNativeComponent';
-import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
-import type {TextInputNativeCommands} from './TextInputNativeCommands';
-type NativeType = HostComponent<mixed>;
-
-type NativeCommands = TextInputNativeCommands<NativeType>;
-
-export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['focus', 'blur', 'setTextAndSelection'],
-});
-
-const WindowsTextInputComponent: NativeType =
-  requireNativeComponent<mixed>('RCTTextInput');
-
-export default WindowsTextInputComponent;
-// [Windows]

package/Libraries/Interaction/Batchinator.js

@@ -1,76 +0,0 @@
-/**
- * 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
- */
-
-'use strict';
-
-const InteractionManager = require('./InteractionManager');
-
-/**
- * A simple class for batching up invocations of a low-pri callback. A timeout is set to run the
- * callback once after a delay, no matter how many times it's scheduled. Once the delay is reached,
- * InteractionManager.runAfterInteractions is used to invoke the callback after any hi-pri
- * interactions are done running.
- *
- * Make sure to cleanup with dispose().  Example:
- *
- *   class Widget extends React.Component {
- *     _batchedSave: new Batchinator(() => this._saveState, 1000);
- *     _saveSate() {
- *       // save this.state to disk
- *     }
- *     componentDidUpdate() {
- *       this._batchedSave.schedule();
- *     }
- *     componentWillUnmount() {
- *       this._batchedSave.dispose();
- *     }
- *     ...
- *   }
- */
-class Batchinator {
-  _callback: () => void;
-  _delay: number;
-  _taskHandle: ?{cancel: () => void, ...};
-  constructor(callback: () => void, delayMS: number) {
-    this._delay = delayMS;
-    this._callback = callback;
-  }
-  /*
-   * Cleanup any pending tasks.
-   *
-   * By default, if there is a pending task the callback is run immediately. Set the option abort to
-   * true to not call the callback if it was pending.
-   */
-  dispose(options: {abort: boolean, ...} = {abort: false}) {
-    if (this._taskHandle) {
-      this._taskHandle.cancel();
-      if (!options.abort) {
-        this._callback();
-      }
-      this._taskHandle = null;
-    }
-  }
-  schedule() {
-    if (this._taskHandle) {
-      return;
-    }
-    const timeoutHandle = setTimeout(() => {
-      this._taskHandle = InteractionManager.runAfterInteractions(() => {
-        // Note that we clear the handle before invoking the callback so that if the callback calls
-        // schedule again, it will actually schedule another task.
-        this._taskHandle = null;
-        this._callback();
-      });
-    }, this._delay);
-    this._taskHandle = {cancel: () => clearTimeout(timeoutHandle)};
-  }
-}
-
-module.exports = Batchinator;

package/Libraries/Interaction/BridgeSpyStallHandler.js

@@ -1,63 +0,0 @@
-/**
- * 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
- */
-
-'use strict';
-
-import type {SpyData} from '../BatchedBridge/MessageQueue';
-
-const MessageQueue = require('../BatchedBridge/MessageQueue');
-const infoLog = require('../Utilities/infoLog');
-const JSEventLoopWatchdog = require('./JSEventLoopWatchdog');
-
-const BridgeSpyStallHandler = {
-  register: function () {
-    let spyBuffer: Array<SpyData> = [];
-    MessageQueue.spy(data => {
-      spyBuffer.push(data);
-    });
-    const TO_JS = 0;
-    JSEventLoopWatchdog.addHandler({
-      onStall: () => {
-        infoLog(
-          spyBuffer.length + ' bridge messages during stall: ',
-          spyBuffer.map(info => {
-            let args: string | Array<?string> = '<args>';
-            try {
-              args = JSON.stringify(info.args);
-            } catch (e1) {
-              if (Array.isArray(info.args)) {
-                args = info.args.map(arg => {
-                  try {
-                    return JSON.stringify(arg);
-                  } catch (e2) {
-                    return '?';
-                  }
-                });
-              } else {
-                args = 'keys:' + JSON.stringify(Object.keys(info.args));
-              }
-            }
-            return (
-              `${info.type === TO_JS ? 'N->JS' : 'JS->N'} : ` +
-              `${info.module ? info.module + '.' : ''}${
-                info.method
-              }(${JSON.stringify(args)})`
-            );
-          }),
-        );
-      },
-      onIterate: () => {
-        spyBuffer = [];
-      },
-    });
-  },
-};
-
-module.exports = BridgeSpyStallHandler;

package/Libraries/Interaction/InteractionStallDebugger.js

@@ -1,23 +0,0 @@
-/**
- * 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
- */
-
-'use strict';
-
-const BridgeSpyStallHandler = require('./BridgeSpyStallHandler');
-const JSEventLoopWatchdog = require('./JSEventLoopWatchdog');
-
-const InteractionStallDebugger = {
-  install(options: {thresholdMS: number, ...}): void {
-    JSEventLoopWatchdog.install(options);
-    BridgeSpyStallHandler.register();
-  },
-};
-
-module.exports = InteractionStallDebugger;

package/Libraries/Interaction/PanResponder.flow.js

@@ -1,257 +0,0 @@
-/**
- * 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 {PressEvent} from '../Types/CoreEventTypes';
-
-/**
- * `PanResponder` reconciles several touches into a single gesture. It makes
- * single-touch gestures resilient to extra touches, and can be used to
- * recognize simple multi-touch gestures.
- *
- * By default, `PanResponder` holds an `InteractionManager` handle to block
- * long-running JS events from interrupting active gestures.
- *
- * It provides a predictable wrapper of the responder handlers provided by the
- * [gesture responder system](docs/gesture-responder-system.html).
- * For each handler, it provides a new `gestureState` object alongside the
- * native event object:
- *
- * ```
- * onPanResponderMove: (event, gestureState) => {}
- * ```
- *
- * A native event is a synthetic touch event with the following form:
- *
- *  - `nativeEvent`
- *      + `changedTouches` - Array of all touch events that have changed since the last event
- *      + `identifier` - The ID of the touch
- *      + `locationX` - The X position of the touch, relative to the element
- *      + `locationY` - The Y position of the touch, relative to the element
- *      + `pageX` - The X position of the touch, relative to the root element
- *      + `pageY` - The Y position of the touch, relative to the root element
- *      + `target` - The node id of the element receiving the touch event
- *      + `timestamp` - A time identifier for the touch, useful for velocity calculation
- *      + `touches` - Array of all current touches on the screen
- *
- * A `gestureState` object has the following:
- *
- *  - `stateID` - ID of the gestureState- persisted as long as there at least
- *     one touch on screen
- *  - `moveX` - the latest screen coordinates of the recently-moved touch
- *  - `moveY` - the latest screen coordinates of the recently-moved touch
- *  - `x0` - the screen coordinates of the responder grant
- *  - `y0` - the screen coordinates of the responder grant
- *  - `dx` - accumulated distance of the gesture since the touch started
- *  - `dy` - accumulated distance of the gesture since the touch started
- *  - `vx` - current velocity of the gesture
- *  - `vy` - current velocity of the gesture
- *  - `numberActiveTouches` - Number of touches currently on screen
- *
- * ### Basic Usage
- *
- * ```
- *   componentWillMount: function() {
- *     this._panResponder = PanResponder.create({
- *       // Ask to be the responder:
- *       onStartShouldSetPanResponder: (evt, gestureState) => true,
- *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,
- *       onMoveShouldSetPanResponder: (evt, gestureState) => true,
- *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
- *
- *       onPanResponderGrant: (evt, gestureState) => {
- *         // The gesture has started. Show visual feedback so the user knows
- *         // what is happening!
- *
- *         // gestureState.d{x,y} will be set to zero now
- *       },
- *       onPanResponderMove: (evt, gestureState) => {
- *         // The most recent move distance is gestureState.move{X,Y}
- *
- *         // The accumulated gesture distance since becoming responder is
- *         // gestureState.d{x,y}
- *       },
- *       onPanResponderTerminationRequest: (evt, gestureState) => true,
- *       onPanResponderRelease: (evt, gestureState) => {
- *         // The user has released all touches while this view is the
- *         // responder. This typically means a gesture has succeeded
- *       },
- *       onPanResponderTerminate: (evt, gestureState) => {
- *         // Another component has become the responder, so this gesture
- *         // should be cancelled
- *       },
- *       onShouldBlockNativeResponder: (evt, gestureState) => {
- *         // Returns whether this component should block native components from becoming the JS
- *         // responder. Returns true by default. Is currently only supported on android.
- *         return true;
- *       },
- *     });
- *   },
- *
- *   render: function() {
- *     return (
- *       <View {...this._panResponder.panHandlers} />
- *     );
- *   },
- *
- * ```
- *
- * ### Working Example
- *
- * To see it in action, try the
- * [PanResponder example in RNTester](https://github.com/facebook/react-native/blob/HEAD/packages/rn-tester/js/examples/PanResponder/PanResponderExample.js)
- */
-
-export type GestureState = {|
-  /**
-   * ID of the gestureState - persisted as long as there at least one touch on screen
-   */
-  stateID: number,
-
-  /**
-   * The latest screen coordinates of the recently-moved touch
-   */
-  moveX: number,
-
-  /**
-   * The latest screen coordinates of the recently-moved touch
-   */
-  moveY: number,
-
-  /**
-   * The screen coordinates of the responder grant
-   */
-  x0: number,
-
-  /**
-   * The screen coordinates of the responder grant
-   */
-  y0: number,
-
-  /**
-   * Accumulated distance of the gesture since the touch started
-   */
-  dx: number,
-
-  /**
-   * Accumulated distance of the gesture since the touch started
-   */
-  dy: number,
-
-  /**
-   * Current velocity of the gesture
-   */
-  vx: number,
-
-  /**
-   * Current velocity of the gesture
-   */
-  vy: number,
-
-  /**
-   * Number of touches currently on screen
-   */
-  numberActiveTouches: number,
-
-  /**
-   * All `gestureState` accounts for timeStamps up until this value
-   *
-   * @private
-   */
-  _accountsForMovesUpTo: number,
-|};
-
-type ActiveCallback = (
-  event: PressEvent,
-  gestureState: GestureState,
-) => boolean;
-
-type PassiveCallback = (event: PressEvent, gestureState: GestureState) => mixed;
-
-type PanHandlers = {|
-  onMoveShouldSetResponder: (event: PressEvent) => boolean,
-  onMoveShouldSetResponderCapture: (event: PressEvent) => boolean,
-  onResponderEnd: (event: PressEvent) => void,
-  onResponderGrant: (event: PressEvent) => boolean,
-  onResponderMove: (event: PressEvent) => void,
-  onResponderReject: (event: PressEvent) => void,
-  onResponderRelease: (event: PressEvent) => void,
-  onResponderStart: (event: PressEvent) => void,
-  onResponderTerminate: (event: PressEvent) => void,
-  onResponderTerminationRequest: (event: PressEvent) => boolean,
-  onStartShouldSetResponder: (event: PressEvent) => boolean,
-  onStartShouldSetResponderCapture: (event: PressEvent) => boolean,
-|};
-
-type PanResponderConfig = $ReadOnly<{|
-  onMoveShouldSetPanResponder?: ?ActiveCallback,
-  onMoveShouldSetPanResponderCapture?: ?ActiveCallback,
-  onStartShouldSetPanResponder?: ?ActiveCallback,
-  onStartShouldSetPanResponderCapture?: ?ActiveCallback,
-  /**
-   * The body of `onResponderGrant` returns a bool, but the vast majority of
-   * callsites return void and this TODO notice is found in it:
-   *   TODO: t7467124 investigate if this can be removed
-   */
-  onPanResponderGrant?: ?(PassiveCallback | ActiveCallback),
-  onPanResponderReject?: ?PassiveCallback,
-  onPanResponderStart?: ?PassiveCallback,
-  onPanResponderEnd?: ?PassiveCallback,
-  onPanResponderRelease?: ?PassiveCallback,
-  onPanResponderMove?: ?PassiveCallback,
-  onPanResponderTerminate?: ?PassiveCallback,
-  onPanResponderTerminationRequest?: ?ActiveCallback,
-  onShouldBlockNativeResponder?: ?ActiveCallback,
-|}>;
-
-export type PanResponderType = {
-  _initializeGestureState: (gestureState: GestureState) => void,
-  _updateGestureStateOnMove: (
-    gestureState: GestureState,
-    touchHistory: $PropertyType<PressEvent, 'touchHistory'>,
-  ) => void,
-  /**
-   * @param {object} config Enhanced versions of all of the responder callbacks
-   * that provide not only the typical `ResponderSyntheticEvent`, but also the
-   * `PanResponder` gesture state.  Simply replace the word `Responder` with
-   * `PanResponder` in each of the typical `onResponder*` callbacks. For
-   * example, the `config` object would look like:
-   *
-   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`
-   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`
-   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`
-   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`
-   *  - `onPanResponderReject: (e, gestureState) => {...}`
-   *  - `onPanResponderGrant: (e, gestureState) => {...}`
-   *  - `onPanResponderStart: (e, gestureState) => {...}`
-   *  - `onPanResponderEnd: (e, gestureState) => {...}`
-   *  - `onPanResponderRelease: (e, gestureState) => {...}`
-   *  - `onPanResponderMove: (e, gestureState) => {...}`
-   *  - `onPanResponderTerminate: (e, gestureState) => {...}`
-   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`
-   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`
-   *
-   *  In general, for events that have capture equivalents, we update the
-   *  gestureState once in the capture phase and can use it in the bubble phase
-   *  as well.
-   *
-   *  Be careful with onStartShould* callbacks. They only reflect updated
-   *  `gestureState` for start/end events that bubble/capture to the Node.
-   *  Once the node is the responder, you can rely on every start/end event
-   *  being processed by the gesture and `gestureState` being updated
-   *  accordingly. (numberActiveTouches) may not be totally accurate unless you
-   *  are the responder.
-   */
-  create: (config: PanResponderConfig) => {
-    getInteractionHandle: () => ?number,
-    panHandlers: PanHandlers,
-  },
-};

package/Libraries/Lists/CellRenderMask.js

@@ -1,155 +0,0 @@
-/**
- * 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 invariant from 'invariant';
-
-export type CellRegion = {
-  first: number,
-  last: number,
-  isSpacer: boolean,
-};
-
-export class CellRenderMask {
-  _numCells: number;
-  _regions: Array<CellRegion>;
-
-  constructor(numCells: number) {
-    invariant(
-      numCells >= 0,
-      'CellRenderMask must contain a non-negative number os cells',
-    );
-
-    this._numCells = numCells;
-
-    if (numCells === 0) {
-      this._regions = [];
-    } else {
-      this._regions = [
-        {
-          first: 0,
-          last: numCells - 1,
-          isSpacer: true,
-        },
-      ];
-    }
-  }
-
-  enumerateRegions(): $ReadOnlyArray<CellRegion> {
-    return this._regions;
-  }
-
-  addCells(cells: {first: number, last: number}): void {
-    invariant(
-      cells.first >= 0 &&
-        cells.first < this._numCells &&
-        cells.last >= -1 &&
-        cells.last < this._numCells &&
-        cells.last >= cells.first - 1,
-      'CellRenderMask.addCells called with invalid cell range',
-    );
-
-    // VirtualizedList uses inclusive ranges, where zero-count states are
-    // possible. E.g. [0, -1] for no cells, starting at 0.
-    if (cells.last < cells.first) {
-      return;
-    }
-
-    const [firstIntersect, firstIntersectIdx] = this._findRegion(cells.first);
-    const [lastIntersect, lastIntersectIdx] = this._findRegion(cells.last);
-
-    // Fast-path if the cells to add are already all present in the mask. We
-    // will otherwise need to do some mutation.
-    if (firstIntersectIdx === lastIntersectIdx && !firstIntersect.isSpacer) {
-      return;
-    }
-
-    // We need to replace the existing covered regions with 1-3 new regions
-    // depending whether we need to split spacers out of overlapping regions.
-    const newLeadRegion: Array<CellRegion> = [];
-    const newTailRegion: Array<CellRegion> = [];
-    const newMainRegion: CellRegion = {
-      ...cells,
-      isSpacer: false,
-    };
-
-    if (firstIntersect.first < newMainRegion.first) {
-      if (firstIntersect.isSpacer) {
-        newLeadRegion.push({
-          first: firstIntersect.first,
-          last: newMainRegion.first - 1,
-          isSpacer: true,
-        });
-      } else {
-        newMainRegion.first = firstIntersect.first;
-      }
-    }
-
-    if (lastIntersect.last > newMainRegion.last) {
-      if (lastIntersect.isSpacer) {
-        newTailRegion.push({
-          first: newMainRegion.last + 1,
-          last: lastIntersect.last,
-          isSpacer: true,
-        });
-      } else {
-        newMainRegion.last = lastIntersect.last;
-      }
-    }
-
-    const replacementRegions: Array<CellRegion> = [
-      ...newLeadRegion,
-      newMainRegion,
-      ...newTailRegion,
-    ];
-    const numRegionsToDelete = lastIntersectIdx - firstIntersectIdx + 1;
-    this._regions.splice(
-      firstIntersectIdx,
-      numRegionsToDelete,
-      ...replacementRegions,
-    );
-  }
-
-  numCells(): number {
-    return this._numCells;
-  }
-
-  equals(other: CellRenderMask): boolean {
-    return (
-      this._numCells === other._numCells &&
-      this._regions.length === other._regions.length &&
-      this._regions.every(
-        (region, i) =>
-          region.first === other._regions[i].first &&
-          region.last === other._regions[i].last &&
-          region.isSpacer === other._regions[i].isSpacer,
-      )
-    );
-  }
-
-  _findRegion(cellIdx: number): [CellRegion, number] {
-    let firstIdx = 0;
-    let lastIdx = this._regions.length - 1;
-
-    while (firstIdx <= lastIdx) {
-      const middleIdx = Math.floor((firstIdx + lastIdx) / 2);
-      const middleRegion = this._regions[middleIdx];
-
-      if (cellIdx >= middleRegion.first && cellIdx <= middleRegion.last) {
-        return [middleRegion, middleIdx];
-      } else if (cellIdx < middleRegion.first) {
-        lastIdx = middleIdx - 1;
-      } else if (cellIdx > middleRegion.last) {
-        firstIdx = middleIdx + 1;
-      }
-    }
-
-    invariant(false, `A region was not found containing cellIdx ${cellIdx}`);
-  }
-}