@office-iss/react-native-win32 0.73.2 → 0.74.0-preview.1

package/Libraries/Components/Text/TextWin32.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TextWin32.js","sourceRoot":"","sources":["../../../src/Libraries/Components/Text/TextWin32.tsx"],"names":[],"mappings":";;;;;;AAAA,kDAAyB;AACzB,mCAAoC;AAepC,MAAa,SAAU,SAAQ,eAAK,CAAC,SAA8B;IACjE,YAAY,KAAsB;QAChC,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;IAEM,MAAM;QACX,OAAO,8BAAC,EAAE,CAAC,IAAI,OAAM,IAAI,CAAC,KAAwB,GAAI,CAAC;IACzD,CAAC;CACF;AARD,8BAQC","sourcesContent":["import React from 'react'\nimport RN = require('react-native');\nimport type { ITextWin32Props } from './TextWin32.Props';\n\n/**\n * All of TOrigin except Key from TUse\n */\ntype UseFrom<TOrigin, TUse, Key extends keyof TUse> = Pick<TOrigin, Exclude<keyof TOrigin, Key>> & Pick<TUse, Key>;\n\n/**\n * React-native <Text> control with additional Win32-specific functionality.\n */\n\ntype InnerViewProps = UseFrom<ITextWin32Props, RN.TextProps, 'accessibilityRole'> &\n  UseFrom<ITextWin32Props, RN.TextProps, 'accessibilityState'> &\n  UseFrom<ITextWin32Props, RN.TextProps, 'accessibilityActions'>;\nexport class TextWin32 extends React.Component<ITextWin32Props, {}> {\n  constructor(props: ITextWin32Props) {\n    super(props);\n  }\n\n  public render() {\n    return <RN.Text {...(this.props as InnerViewProps)} />;\n  }\n}\n"]}

package/Libraries/Components/Touchable/Touchable.flow.js

@@ -1,284 +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
- */
-
-import type {EdgeInsetsProp} from '../../StyleSheet/EdgeInsetsPropType';
-import type {ColorValue} from '../../StyleSheet/StyleSheet';
-import type {PressEvent} from '../../Types/CoreEventTypes';
-
-import * as React from 'react';
-
-/**
- * `Touchable`: Taps done right.
- *
- * You hook your `ResponderEventPlugin` events into `Touchable`. `Touchable`
- * will measure time/geometry and tells you when to give feedback to the user.
- *
- * ====================== Touchable Tutorial ===============================
- * The `Touchable` mixin helps you handle the "press" interaction. It analyzes
- * the geometry of elements, and observes when another responder (scroll view
- * etc) has stolen the touch lock. It notifies your component when it should
- * give feedback to the user. (bouncing/highlighting/unhighlighting).
- *
- * - When a touch was activated (typically you highlight)
- * - When a touch was deactivated (typically you unhighlight)
- * - When a touch was "pressed" - a touch ended while still within the geometry
- *   of the element, and no other element (like scroller) has "stolen" touch
- *   lock ("responder") (Typically you bounce the element).
- *
- * A good tap interaction isn't as simple as you might think. There should be a
- * slight delay before showing a highlight when starting a touch. If a
- * subsequent touch move exceeds the boundary of the element, it should
- * unhighlight, but if that same touch is brought back within the boundary, it
- * should rehighlight again. A touch can move in and out of that boundary
- * several times, each time toggling highlighting, but a "press" is only
- * triggered if that touch ends while within the element's boundary and no
- * scroller (or anything else) has stolen the lock on touches.
- *
- * To create a new type of component that handles interaction using the
- * `Touchable` mixin, do the following:
- *
- * - Initialize the `Touchable` state.
- *
- *   getInitialState: function() {
- *     return merge(this.touchableGetInitialState(), yourComponentState);
- *   }
- *
- * - Choose the rendered component who's touches should start the interactive
- *   sequence. On that rendered node, forward all `Touchable` responder
- *   handlers. You can choose any rendered node you like. Choose a node whose
- *   hit target you'd like to instigate the interaction sequence:
- *
- *   // In render function:
- *   return (
- *     <View
- *       onStartShouldSetResponder={this.touchableHandleStartShouldSetResponder}
- *       onResponderTerminationRequest={this.touchableHandleResponderTerminationRequest}
- *       onResponderGrant={this.touchableHandleResponderGrant}
- *       onResponderMove={this.touchableHandleResponderMove}
- *       onResponderRelease={this.touchableHandleResponderRelease}
- *       onResponderTerminate={this.touchableHandleResponderTerminate}>
- *       <View>
- *         Even though the hit detection/interactions are triggered by the
- *         wrapping (typically larger) node, we usually end up implementing
- *         custom logic that highlights this inner one.
- *       </View>
- *     </View>
- *   );
- *
- * - You may set up your own handlers for each of these events, so long as you
- *   also invoke the `touchable*` handlers inside of your custom handler.
- *
- * - Implement the handlers on your component class in order to provide
- *   feedback to the user. See documentation for each of these class methods
- *   that you should implement.
- *
- *   touchableHandlePress: function() {
- *      this.performBounceAnimation();  // or whatever you want to do.
- *   },
- *   touchableHandleActivePressIn: function() {
- *     this.beginHighlighting(...);  // Whatever you like to convey activation
- *   },
- *   touchableHandleActivePressOut: function() {
- *     this.endHighlighting(...);  // Whatever you like to convey deactivation
- *   },
- *
- * - There are more advanced methods you can implement (see documentation below):
- *   touchableGetHighlightDelayMS: function() {
- *     return 20;
- *   }
- *   // In practice, *always* use a predeclared constant (conserve memory).
- *   touchableGetPressRectOffset: function() {
- *     return {top: 20, left: 20, right: 20, bottom: 100};
- *   }
- */
-
-/**
- * Touchable states.
- */
-
-const States = {
-  NOT_RESPONDER: 'NOT_RESPONDER', // Not the responder
-  RESPONDER_INACTIVE_PRESS_IN: 'RESPONDER_INACTIVE_PRESS_IN', // Responder, inactive, in the `PressRect`
-  RESPONDER_INACTIVE_PRESS_OUT: 'RESPONDER_INACTIVE_PRESS_OUT', // Responder, inactive, out of `PressRect`
-  RESPONDER_ACTIVE_PRESS_IN: 'RESPONDER_ACTIVE_PRESS_IN', // Responder, active, in the `PressRect`
-  RESPONDER_ACTIVE_PRESS_OUT: 'RESPONDER_ACTIVE_PRESS_OUT', // Responder, active, out of `PressRect`
-  RESPONDER_ACTIVE_LONG_PRESS_IN: 'RESPONDER_ACTIVE_LONG_PRESS_IN', // Responder, active, in the `PressRect`, after long press threshold
-  RESPONDER_ACTIVE_LONG_PRESS_OUT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT', // Responder, active, out of `PressRect`, after long press threshold
-  ERROR: 'ERROR',
-};
-
-type State =
-  | typeof States.NOT_RESPONDER
-  | typeof States.RESPONDER_INACTIVE_PRESS_IN
-  | typeof States.RESPONDER_INACTIVE_PRESS_OUT
-  | typeof States.RESPONDER_ACTIVE_PRESS_IN
-  | typeof States.RESPONDER_ACTIVE_PRESS_OUT
-  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_IN
-  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_OUT
-  | typeof States.ERROR;
-
-/**
- * By convention, methods prefixed with underscores are meant to be @private,
- * and not @protected. Mixers shouldn't access them - not even to provide them
- * as callback handlers.
- *
- *
- * ========== Geometry =========
- * `Touchable` only assumes that there exists a `HitRect` node. The `PressRect`
- * is an abstract box that is extended beyond the `HitRect`.
- *
- *  +--------------------------+
- *  |                          | - "Start" events in `HitRect` cause `HitRect`
- *  |  +--------------------+  |   to become the responder.
- *  |  |  +--------------+  |  | - `HitRect` is typically expanded around
- *  |  |  |              |  |  |   the `VisualRect`, but shifted downward.
- *  |  |  |  VisualRect  |  |  | - After pressing down, after some delay,
- *  |  |  |              |  |  |   and before letting up, the Visual React
- *  |  |  +--------------+  |  |   will become "active". This makes it eligible
- *  |  |     HitRect        |  |   for being highlighted (so long as the
- *  |  +--------------------+  |   press remains in the `PressRect`).
- *  |        PressRect     o   |
- *  +----------------------|---+
- *           Out Region    |
- *                         +-----+ This gap between the `HitRect` and
- *                                 `PressRect` allows a touch to move far away
- *                                 from the original hit rect, and remain
- *                                 highlighted, and eligible for a "Press".
- *                                 Customize this via
- *                                 `touchableGetPressRectOffset()`.
- *
- *
- *
- * ======= State Machine =======
- *
- * +-------------+ <---+ RESPONDER_RELEASE
- * |NOT_RESPONDER|
- * +-------------+ <---+ RESPONDER_TERMINATED
- *     +
- *     | RESPONDER_GRANT (HitRect)
- *     v
- * +---------------------------+  DELAY   +-------------------------+  T + DELAY     +------------------------------+
- * |RESPONDER_INACTIVE_PRESS_IN|+-------->|RESPONDER_ACTIVE_PRESS_IN| +------------> |RESPONDER_ACTIVE_LONG_PRESS_IN|
- * +---------------------------+          +-------------------------+                +------------------------------+
- *     +            ^                         +           ^                                 +           ^
- *     |LEAVE_      |ENTER_                   |LEAVE_     |ENTER_                           |LEAVE_     |ENTER_
- *     |PRESS_RECT  |PRESS_RECT               |PRESS_RECT |PRESS_RECT                       |PRESS_RECT |PRESS_RECT
- *     |            |                         |           |                                 |           |
- *     v            +                         v           +                                 v           +
- * +----------------------------+  DELAY  +--------------------------+               +-------------------------------+
- * |RESPONDER_INACTIVE_PRESS_OUT|+------->|RESPONDER_ACTIVE_PRESS_OUT|               |RESPONDER_ACTIVE_LONG_PRESS_OUT|
- * +----------------------------+         +--------------------------+               +-------------------------------+
- *
- * T + DELAY => LONG_PRESS_DELAY_MS + DELAY
- *
- * Not drawn are the side effects of each transition. The most important side
- * effect is the `touchableHandlePress` abstract method invocation that occurs
- * when a responder is released while in either of the "Press" states.
- *
- * The other important side effects are the highlight abstract method
- * invocations (internal callbacks) to be implemented by the mixer.
- *
- *
- * @lends Touchable.prototype
- */
-interface TouchableMixinType {
-  /**
-   * Invoked when the item receives focus. Mixers might override this to
-   * visually distinguish the `VisualRect` so that the user knows that it
-   * currently has the focus. Most platforms only support a single element being
-   * focused at a time, in which case there may have been a previously focused
-   * element that was blurred just prior to this. This can be overridden when
-   * using `Touchable.Mixin.withoutDefaultFocusAndBlur`.
-   */
-  touchableHandleFocus: (e: Event) => void;
-
-  /**
-   * Invoked when the item loses focus. Mixers might override this to
-   * visually distinguish the `VisualRect` so that the user knows that it
-   * no longer has focus. Most platforms only support a single element being
-   * focused at a time, in which case the focus may have moved to another.
-   * This can be overridden when using
-   * `Touchable.Mixin.withoutDefaultFocusAndBlur`.
-   */
-  touchableHandleBlur: (e: Event) => void;
-
-  componentDidMount: () => void;
-
-  /**
-   * Clear all timeouts on unmount
-   */
-  componentWillUnmount: () => void;
-
-  /**
-   * It's prefer that mixins determine state in this way, having the class
-   * explicitly mix the state in the one and only `getInitialState` method.
-   *
-   * @return {object} State object to be placed inside of
-   * `this.state.touchable`.
-   */
-  touchableGetInitialState: () => {
-    touchable: {
-      touchState: ?State,
-      responderID: ?PressEvent['currentTarget'],
-    },
-  };
-
-  // ==== Hooks to Gesture Responder system ====
-  /**
-   * Must return true if embedded in a native platform scroll view.
-   */
-  touchableHandleResponderTerminationRequest: () => any;
-
-  /**
-   * Must return true to start the process of `Touchable`.
-   */
-  touchableHandleStartShouldSetResponder: () => any;
-
-  /**
-   * Return true to cancel press on long press.
-   */
-  touchableLongPressCancelsPress: () => boolean;
-
-  /**
-   * Place as callback for a DOM element's `onResponderGrant` event.
-   * @param {SyntheticEvent} e Synthetic event from event system.
-   *
-   */
-  touchableHandleResponderGrant: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderRelease` event.
-   */
-  touchableHandleResponderRelease: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderTerminate` event.
-   */
-  touchableHandleResponderTerminate: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderMove` event.
-   */
-  touchableHandleResponderMove: (e: PressEvent) => void;
-
-  withoutDefaultFocusAndBlur: {...};
-}
-
-export type TouchableType = {
-  Mixin: TouchableMixinType,
-  /**
-   * Renders a debugging overlay to visualize touch target with hitSlop (might not work on Android).
-   */
-  renderDebugView: ({
-    color: ColorValue,
-    hitSlop: EdgeInsetsProp,
-    ...
-  }) => null | React.Node,
-};

package/Libraries/Components/TraceUpdateOverlay/TraceUpdateOverlay.js

@@ -1,189 +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-local
- * @format
- */
-
-import type {Overlay} from './TraceUpdateOverlayNativeComponent';
-
-import UIManager from '../../ReactNative/UIManager';
-import processColor from '../../StyleSheet/processColor';
-import StyleSheet from '../../StyleSheet/StyleSheet';
-import Platform from '../../Utilities/Platform';
-import View from '../View/View';
-import TraceUpdateOverlayNativeComponent, {
-  Commands,
-} from './TraceUpdateOverlayNativeComponent';
-import * as React from 'react';
-
-type AgentEvents = {
-  drawTraceUpdates: [Array<{node: TraceNode, color: string}>],
-  disableTraceUpdates: [],
-};
-
-interface Agent {
-  addListener<Event: $Keys<AgentEvents>>(
-    event: Event,
-    listener: (...AgentEvents[Event]) => void,
-  ): void;
-  removeListener(event: $Keys<AgentEvents>, listener: () => void): void;
-}
-
-type PublicInstance = {
-  measure?: (
-    (
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      left: number,
-      top: number,
-    ) => void,
-  ) => void,
-};
-
-type TraceNode =
-  | PublicInstance
-  | {
-      canonical?:
-        | PublicInstance // TODO: remove this variant when syncing the new version of the renderer from React to React Native.
-        | {
-            publicInstance?: PublicInstance,
-          },
-    };
-
-type ReactDevToolsGlobalHook = {
-  on: (eventName: string, (agent: Agent) => void) => void,
-  off: (eventName: string, (agent: Agent) => void) => void,
-  reactDevtoolsAgent: Agent,
-};
-
-const {useEffect, useRef, useState} = React;
-const hook: ReactDevToolsGlobalHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-const isNativeComponentReady =
-  Platform.OS === 'android' &&
-  UIManager.hasViewManagerConfig('TraceUpdateOverlay');
-let devToolsAgent: ?Agent;
-
-export default function TraceUpdateOverlay(): React.Node {
-  const [overlayDisabled, setOverlayDisabled] = useState(false);
-  // This effect is designed to be explicitly shown here to avoid re-subscribe from the same
-  // overlay component.
-  useEffect(() => {
-    if (!isNativeComponentReady) {
-      return;
-    }
-
-    function attachToDevtools(agent: Agent) {
-      devToolsAgent = agent;
-      agent.addListener('drawTraceUpdates', onAgentDrawTraceUpdates);
-      agent.addListener('disableTraceUpdates', onAgentDisableTraceUpdates);
-    }
-
-    function subscribe() {
-      hook?.on('react-devtools', attachToDevtools);
-      if (hook?.reactDevtoolsAgent) {
-        attachToDevtools(hook.reactDevtoolsAgent);
-      }
-    }
-
-    function unsubscribe() {
-      hook?.off('react-devtools', attachToDevtools);
-      const agent = devToolsAgent;
-      if (agent != null) {
-        agent.removeListener('drawTraceUpdates', onAgentDrawTraceUpdates);
-        agent.removeListener('disableTraceUpdates', onAgentDisableTraceUpdates);
-        devToolsAgent = null;
-      }
-    }
-
-    function onAgentDrawTraceUpdates(
-      nodesToDraw: Array<{node: TraceNode, color: string}> = [],
-    ) {
-      // If overlay is disabled before, now it's enabled.
-      setOverlayDisabled(false);
-
-      const newFramesToDraw: Array<Promise<Overlay>> = [];
-      nodesToDraw.forEach(({node, color}) => {
-        // `canonical.publicInstance` => Fabric
-        // TODO: remove this check when syncing the new version of the renderer from React to React Native.
-        // `canonical` => Legacy Fabric
-        // `node` => Legacy renderer
-        const component =
-          (node.canonical && node.canonical.publicInstance) ??
-          node.canonical ??
-          node;
-        if (!component || !component.measure) {
-          return;
-        }
-        const frameToDrawPromise = new Promise<Overlay>(resolve => {
-          // The if statement here is to make flow happy
-          if (component.measure) {
-            // TODO(T145522797): We should refactor this to use `getBoundingClientRect` when Paper is no longer supported.
-            component.measure((x, y, width, height, left, top) => {
-              resolve({
-                rect: {left, top, width, height},
-                color: processColor(color),
-              });
-            });
-          }
-        });
-        newFramesToDraw.push(frameToDrawPromise);
-      });
-      Promise.all(newFramesToDraw).then(
-        results => {
-          if (nativeComponentRef.current != null) {
-            Commands.draw(
-              nativeComponentRef.current,
-              JSON.stringify(
-                results.filter(
-                  ({rect, color}) => rect.width >= 0 && rect.height >= 0,
-                ),
-              ),
-            );
-          }
-        },
-        err => {
-          console.error(`Failed to measure updated traces. Error: ${err}`);
-        },
-      );
-    }
-
-    function onAgentDisableTraceUpdates() {
-      // When trace updates are disabled from the backend, we won't receive draw events until it's enabled by the next draw. We can safely remove the overlay as it's not needed now.
-      setOverlayDisabled(true);
-    }
-
-    subscribe();
-    return unsubscribe;
-  }, []); // Only run once when the overlay initially rendered
-
-  const nativeComponentRef =
-    useRef<?React.ElementRef<typeof TraceUpdateOverlayNativeComponent>>(null);
-
-  return (
-    !overlayDisabled &&
-    isNativeComponentReady && (
-      <View pointerEvents="none" style={styles.overlay}>
-        <TraceUpdateOverlayNativeComponent
-          ref={nativeComponentRef}
-          style={styles.overlay}
-        />
-      </View>
-    )
-  );
-}
-
-const styles = StyleSheet.create({
-  overlay: {
-    position: 'absolute',
-    top: 0,
-    bottom: 0,
-    left: 0,
-    right: 0,
-  },
-});

package/Libraries/Components/TraceUpdateOverlay/TraceUpdateOverlayNativeComponent.js

@@ -1,43 +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-local
- * @format
- */
-
-import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
-import type {ProcessedColorValue} from '../../StyleSheet/processColor';
-import type {ViewProps} from '../View/ViewPropTypes';
-
-import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
-import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
-import * as React from 'react';
-
-type NativeProps = $ReadOnly<{|
-  ...ViewProps,
-|}>;
-export type TraceUpdateOverlayNativeComponentType = HostComponent<NativeProps>;
-export type Overlay = {
-  rect: {left: number, top: number, width: number, height: number},
-  color: ?ProcessedColorValue,
-};
-
-interface NativeCommands {
-  +draw: (
-    viewRef: React.ElementRef<TraceUpdateOverlayNativeComponentType>,
-    // TODO(T144046177): Ideally we can pass array of Overlay, but currently
-    // Array type is not supported in RN codegen for building native commands.
-    overlays: string,
-  ) => void;
-}
-
-export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['draw'],
-});
-
-export default (codegenNativeComponent<NativeProps>(
-  'TraceUpdateOverlay',
-): HostComponent<NativeProps>);

package/Libraries/Image/Image.flow.js

@@ -1,64 +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
- */
-
-import type {RootTag} from '../Types/RootTagTypes';
-import type {ResolvedAssetSource} from './AssetSourceResolver';
-import type {ImageProps as ImagePropsType} from './ImageProps';
-
-import ImageViewNativeComponent from './ImageViewNativeComponent';
-import TextInlineImageNativeComponent from './TextInlineImageNativeComponent';
-import * as React from 'react';
-
-type ImageComponentStaticsIOS = $ReadOnly<{|
-  getSize: (
-    uri: string,
-    success: (width: number, height: number) => void,
-    failure?: (error: any) => void,
-  ) => void,
-
-  getSizeWithHeaders(
-    uri: string,
-    headers: {[string]: string, ...},
-    success: (width: number, height: number) => void,
-    failure?: (error: any) => void,
-  ): any,
-
-  prefetch(url: string): any,
-
-  prefetchWithMetadata(
-    url: string,
-    queryRootName: string,
-    rootTag?: ?RootTag,
-  ): any,
-
-  queryCache(
-    urls: Array<string>,
-  ): Promise<{[string]: 'memory' | 'disk' | 'disk/memory', ...}>,
-
-  resolveAssetSource(source: any): ?ResolvedAssetSource,
-|}>;
-
-type ImageComponentStaticsAndroid = {
-  ...ImageComponentStaticsIOS,
-  abortPrefetch(requestId: number): void,
-};
-
-export type ImageAndroid = React.AbstractComponent<
-  ImagePropsType,
-  | React.ElementRef<typeof TextInlineImageNativeComponent>
-  | React.ElementRef<typeof ImageViewNativeComponent>,
-> &
-  ImageComponentStaticsAndroid;
-
-export type ImageIOS = React.AbstractComponent<
-  ImagePropsType,
-  React.ElementRef<typeof ImageViewNativeComponent>,
-> &
-  ImageComponentStaticsIOS;