@hanzogui/react-native-web-lite 8.3.0 → 8.3.2

package/types/vendor/react-native/Animated/nodes/AnimatedWithChildren.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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
+ * @format
+ */
+import { AnimatedNode } from './AnimatedNode.js';
+declare class AnimatedWithChildren extends AnimatedNode {
+    _children: any;
+    constructor();
+    __makeNative(platformConfig: any): void;
+    __addChild(child: any): void;
+    __removeChild(child: any): void;
+    __getChildren(): any;
+    __callListeners(value: any): void;
+}
+export { AnimatedWithChildren };
+export default AnimatedWithChildren;
+//# sourceMappingURL=AnimatedWithChildren.d.ts.map

package/types/vendor/react-native/Animated/nodes/AnimatedWithChildren.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedWithChildren.d.ts","sourceRoot":"","sources":["../../../../../src/vendor/react-native/Animated/nodes/AnimatedWithChildren.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,cAAM,oBAAqB,SAAQ,YAAY;IAC7C,SAAS,MAAA;IAET,cAGC;IAED,YAAY,CAAC,cAAc,KAAA,QAY1B;IAED,UAAU,CAAC,KAAK,KAAA,QAaf;IAED,aAAa,CAAC,KAAK,KAAA,QAgBlB;IAED,aAAa,QAEZ;IAED,eAAe,CAAC,KAAK,KAAA,QAUpB;CACF;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA;eAChB,oBAAoB"}

package/types/vendor/react-native/Animated/useAnimatedProps.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ * @format
+ */
+declare function useAnimatedProps(props: any): any[];
+export { useAnimatedProps };
+export default useAnimatedProps;
+//# sourceMappingURL=useAnimatedProps.d.ts.map

package/types/vendor/react-native/Animated/useAnimatedProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimatedProps.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/Animated/useAnimatedProps.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH,iBAAS,gBAAgB,CAAC,KAAK,KAAA,SAiE9B;AAoFD,OAAO,EAAE,gBAAgB,EAAE,CAAA;eACZ,gBAAgB"}

package/types/vendor/react-native/Batchinator/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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
+ * @format
+ */
+/**
+ * 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();
+ *     }
+ *     ...
+ *   }
+ */
+declare class Batchinator {
+    _callback: any;
+    _delay: any;
+    _taskHandle: any;
+    constructor(callback: any, delayMS: any);
+    dispose(options?: {
+        abort: boolean;
+    }): void;
+    schedule(): void;
+}
+export { Batchinator };
+export default Batchinator;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/Batchinator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/Batchinator/index.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,cAAM,WAAW;IACf,SAAS,MAAA;IACT,MAAM,MAAA;IACN,WAAW,MAAA;IACX,YAAY,QAAQ,KAAA,EAAE,OAAO,KAAA,EAG5B;IAOD,OAAO,CAAC,OAAO;QAAK,KAAK;KAAS,QAQjC;IACD,QAAQ,SAaP;CACF;AAED,OAAO,EAAE,WAAW,EAAE,CAAA;eACP,WAAW"}

package/types/vendor/react-native/EventEmitter/NativeEventEmitter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+/**
+ * `NativeEventEmitter` is intended for use by Native Modules to emit events to
+ * JavaScript listeners. If a `NativeModule` is supplied to the constructor, it
+ * will be notified (via `addListener` and `removeListeners`) when the listener
+ * count changes to manage "native memory".
+ *
+ * Currently, all native events are fired via a global `RCTDeviceEventEmitter`.
+ * This means event names must be globally unique, and it means that call sites
+ * can theoretically listen to `RCTDeviceEventEmitter` (although discouraged).
+ */
+declare class NativeEventEmitter {
+    _nativeModule: any;
+    constructor(nativeModule: any);
+    addListener(eventType: any, listener: any, context: any): {
+        remove: () => void;
+    };
+    /**
+     * @deprecated Use `remove` on the EventSubscription from `addListener`.
+     */
+    removeListener(eventType: any, listener: any): void;
+    emit(eventType: any, ...args: any[]): void;
+    removeAllListeners(eventType: any): void;
+    listenerCount(eventType: any): number;
+}
+export { NativeEventEmitter };
+export default NativeEventEmitter;
+//# sourceMappingURL=NativeEventEmitter.d.ts.map

package/types/vendor/react-native/EventEmitter/NativeEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeEventEmitter.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/EventEmitter/NativeEventEmitter.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;;;;;;;;GASG;AACH,cAAM,kBAAkB;IACtB,aAAa,MAAA;IAEb,YAAY,YAAY,KAAA,EAQvB;IAED,WAAW,CAAC,SAAS,KAAA,EAAE,QAAQ,KAAA,EAAE,OAAO,KAAA;QAKpC,MAAM;MAST;IAED;;OAEG;IACH,cAAc,CAAC,SAAS,KAAA,EAAE,QAAQ,KAAA,QAKjC;IAED,IAAI,CAAC,SAAS,KAAA,EAAE,GAAG,IAAI,OAAA,QAItB;IAED,kBAAkB,CAAC,SAAS,KAAA,QAO3B;IAED,aAAa,CAAC,SAAS,KAAA,UAEtB;CACF;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAA;eACd,kBAAkB"}

package/types/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+import { EventEmitter } from '../emitter/EventEmitter.js';
+/**
+ * Global EventEmitter used by the native platform to emit events to JavaScript.
+ * Events are identified by globally unique event names.
+ *
+ * NativeModules that emit events should instead subclass `NativeEventEmitter`.
+ */
+declare const RCTDeviceEventEmitter: EventEmitter;
+export { RCTDeviceEventEmitter };
+export default RCTDeviceEventEmitter;
+//# sourceMappingURL=RCTDeviceEventEmitter.d.ts.map

package/types/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RCTDeviceEventEmitter.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAIzD;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB,cAAqB,CAAA;AAChD,OAAO,EAAE,qBAAqB,EAAE,CAAA;eACjB,qBAAqB"}

package/types/vendor/react-native/FeatureFlags.d.ts

@@ -0,0 +1,9 @@
+export declare const ReactNativeFeatureFlags: {
+    isLayoutAnimationEnabled: () => boolean;
+    shouldEmitW3CPointerEvents: () => boolean;
+    shouldPressibilityUseW3CPointerEventsForHover: () => boolean;
+    animatedShouldDebounceQueueFlush: () => boolean;
+    animatedShouldUseSingleOp: () => boolean;
+    enableCppComponents: () => boolean;
+};
+//# sourceMappingURL=FeatureFlags.d.ts.map

package/types/vendor/react-native/FeatureFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureFlags.d.ts","sourceRoot":"","sources":["../../../src/vendor/react-native/FeatureFlags.js"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB;IAClC,wBAAwB;IACxB,0BAA0B;IAC1B,6CAA6C;IAC7C,gCAAgC;IAChC,yBAAyB;IACzB,mBAAmB;CACpB,CAAA"}

package/types/vendor/react-native/FillRateHelper/index.d.ts

@@ -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
+ * @format
+ */
+declare class Info {
+    any_blank_count: number;
+    any_blank_ms: number;
+    any_blank_speed_sum: number;
+    mostly_blank_count: number;
+    mostly_blank_ms: number;
+    pixels_blank: number;
+    pixels_sampled: number;
+    pixels_scrolled: number;
+    total_time_spent: number;
+    sample_count: number;
+}
+/**
+ * A helper class for detecting when the maximem fill rate of `VirtualizedList` is exceeded.
+ * By default the sampling rate is set to zero and this will do nothing. If you want to collect
+ * samples (e.g. to log them), make sure to call `FillRateHelper.setSampleRate(0.0-1.0)`.
+ *
+ * Listeners and sample rate are global for all `VirtualizedList`s - typical usage will combine with
+ * `SceneTracker.getActiveScene` to determine the context of the events.
+ */
+declare class FillRateHelper {
+    _anyBlankStartTime: null;
+    _enabled: boolean;
+    _getFrameMetrics: any;
+    _info: Info;
+    _mostlyBlankStartTime: null;
+    _samplesStartTime: null;
+    static addListener(callback: any): {
+        remove: () => void;
+    };
+    static setSampleRate(sampleRate: any): void;
+    static setMinSampleCount(minSampleCount: any): void;
+    constructor(getFrameMetrics: any);
+    activate(): void;
+    deactivateAndFlush(): void;
+    computeBlankness(props: any, cellsAroundViewport: any, scrollMetrics: any): number;
+    enabled(): boolean;
+    _resetData(): void;
+}
+export { FillRateHelper };
+export default FillRateHelper;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/FillRateHelper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/FillRateHelper/index.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAM,IAAI;IACR,eAAe,SAAI;IACnB,YAAY,SAAI;IAChB,mBAAmB,SAAI;IACvB,kBAAkB,SAAI;IACtB,eAAe,SAAI;IACnB,YAAY,SAAI;IAChB,cAAc,SAAI;IAClB,eAAe,SAAI;IACnB,gBAAgB,SAAI;IACpB,YAAY,SAAI;CACjB;AAcD;;;;;;;GAOG;AACH,cAAM,cAAc;IAClB,kBAAkB,OAAO;IACzB,QAAQ,UAAQ;IAChB,gBAAgB,MAAA;IAChB,KAAK,OAAa;IAClB,qBAAqB,OAAO;IAC5B,iBAAiB,OAAO;IAExB,MAAM,CAAC,WAAW,CAAC,QAAQ,KAAA;QAMvB,MAAM;MAIT;IAED,MAAM,CAAC,aAAa,CAAC,UAAU,KAAA,QAE9B;IAED,MAAM,CAAC,iBAAiB,CAAC,cAAc,KAAA,QAEtC;IAED,YAAY,eAAe,KAAA,EAI1B;IAED,QAAQ,SAKP;IAED,kBAAkB,SAuCjB;IAED,gBAAgB,CAAC,KAAK,KAAA,EAAE,mBAAmB,KAAA,EAAE,aAAa,KAAA,UAwEzD;IAED,OAAO,YAEN;IAED,UAAU,SAKT;CACF;AAED,OAAO,EAAE,cAAc,EAAE,CAAA;eACV,cAAc"}

package/types/vendor/react-native/FlatList/index.d.ts

@@ -0,0 +1,196 @@
+/**
+ * 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
+ * @format
+ */
+import * as React from 'react';
+/**
+ * A performant interface for rendering simple, flat lists, supporting the most handy features:
+ *
+ *  - Fully cross-platform.
+ *  - Optional horizontal mode.
+ *  - Configurable viewability callbacks.
+ *  - Header support.
+ *  - Footer support.
+ *  - Separator support.
+ *  - Pull to Refresh.
+ *  - Scroll loading.
+ *  - ScrollToIndex support.
+ *
+ * If you need section support, use [`<SectionList>`](docs/sectionlist.html).
+ *
+ * Minimal Example:
+ *
+ *     <FlatList
+ *       data={[{key: 'a'}, {key: 'b'}]}
+ *       renderItem={({item}) => <Text>{item.key}</Text>}
+ *     />
+ *
+ * More complex, multi-select example demonstrating `PureComponent` usage for perf optimization and avoiding bugs.
+ *
+ * - By binding the `onPressItem` handler, the props will remain `===` and `PureComponent` will
+ *   prevent wasteful re-renders unless the actual `id`, `selected`, or `title` props change, even
+ *   if the components rendered in `MyListItem` did not have such optimizations.
+ * - By passing `extraData={this.state}` to `FlatList` we make sure `FlatList` itself will re-render
+ *   when the `state.selected` changes. Without setting this prop, `FlatList` would not know it
+ *   needs to re-render any items because it is also a `PureComponent` and the prop comparison will
+ *   not show any changes.
+ * - `keyExtractor` tells the list to use the `id`s for the react keys instead of the default `key` property.
+ *
+ *
+ *     class MyListItem extends React.PureComponent {
+ *       _onPress = () => {
+ *         this.props.onPressItem(this.props.id);
+ *       };
+ *
+ *       render() {
+ *         const textColor = this.props.selected ? "red" : "black";
+ *         return (
+ *           <TouchableOpacity onPress={this._onPress}>
+ *             <View>
+ *
+ *                 {this.props.title}
+ *               </Text>
+ *             </View>
+ *           </TouchableOpacity>
+ *         );
+ *       }
+ *     }
+ *
+ *     class MultiSelectList extends React.PureComponent {
+ *       state = {selected: new Map()};
+ *
+ *       _keyExtractor = (item, index) => item.id;
+ *
+ *       _onPressItem = (id) => {
+ *         // updater functions are preferred for transactional updates
+ *         this.setState((state) => {
+ *           // copy the map rather than modifying state.
+ *           const selected = new Map(state.selected);
+ *           selected.set(id, !selected.get(id)); // toggle
+ *           return {selected};
+ *         });
+ *       };
+ *
+ *       _renderItem = ({item}) => (
+ *         <MyListItem
+ *           id={item.id}
+ *           onPressItem={this._onPressItem}
+ *           selected={!!this.state.selected.get(item.id)}
+ *           title={item.title}
+ *         />
+ *       );
+ *
+ *       render() {
+ *         return (
+ *           <FlatList
+ *             data={this.props.data}
+ *             extraData={this.state}
+ *             keyExtractor={this._keyExtractor}
+ *             renderItem={this._renderItem}
+ *           />
+ *         );
+ *       }
+ *     }
+ *
+ * This is a convenience wrapper around [`<VirtualizedList>`](docs/virtualizedlist.html),
+ * and thus inherits its props (as well as those of `ScrollView`) that aren't explicitly listed
+ * here, along with the following caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate ands momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ *
+ * Also inherits [ScrollView Props](docs/scrollview.html#props), unless it is nested in another FlatList of same orientation.
+ */
+declare class FlatList extends React.PureComponent {
+    /**
+     * Scrolls to the end of the content. May be janky without `getItemLayout` prop.
+     */
+    scrollToEnd(params: any): void;
+    /**
+     * Scrolls to the item at the specified index such that it is positioned in the viewable area
+     * such that `viewPosition` 0 places it at the top, 1 at the bottom, and 0.5 centered in the
+     * middle. `viewOffset` is a fixed number of pixels to offset the final target position.
+     *
+     * Note: cannot scroll to locations outside the render window without specifying the
+     * `getItemLayout` prop.
+     */
+    scrollToIndex(params: any): void;
+    /**
+     * Requires linear scan through data - use `scrollToIndex` instead if possible.
+     *
+     * Note: cannot scroll to locations outside the render window without specifying the
+     * `getItemLayout` prop.
+     */
+    scrollToItem(params: any): void;
+    /**
+     * Scroll to a specific content pixel offset in the list.
+     *
+     * Check out [scrollToOffset](docs/virtualizedlist.html#scrolltooffset) of VirtualizedList
+     */
+    scrollToOffset(params: any): void;
+    /**
+     * Tells the list an interaction has occurred, which should trigger viewability calculations, e.g.
+     * if `waitForInteractions` is true and the user has not scrolled. This is typically called by
+     * taps on items or by navigation actions.
+     */
+    recordInteraction(): void;
+    /**
+     * Displays the scroll indicators momentarily.
+     *
+     * @platform ios
+     */
+    flashScrollIndicators(): void;
+    /**
+     * Provides a handle to the underlying scroll responder.
+     */
+    getScrollResponder(): any;
+    /**
+     * Provides a reference to the underlying host component
+     */
+    getNativeScrollRef(): any;
+    getScrollableNode(): any;
+    constructor(props: any);
+    componentDidUpdate(prevProps: any): void;
+    _listRef: any;
+    _virtualizedListPairs: any[];
+    _captureRef: (ref: any) => void;
+    _checkProps(props: any): void;
+    _getItem: (data: any, index: any) => any;
+    _getItemCount: (data: any) => any;
+    _keyExtractor: (items: any, index: any) => any;
+    _pushMultiColumnViewable(arr: any, v: any): void;
+    _createOnViewableItemsChanged(onViewableItemsChanged: any): (info: any) => void;
+    _renderer: (ListItemComponent: any, renderItem: any, columnWrapperStyle: any, numColumns: any, extraData: any) => {
+        ListItemComponent: (info: any) => any;
+        renderItem?: undefined;
+    } | {
+        ListItemComponent?: undefined;
+        renderItem: (info: any) => any;
+    };
+    _memoizedRenderer: import("memoize-one").MemoizedFn<(ListItemComponent: any, renderItem: any, columnWrapperStyle: any, numColumns: any, extraData: any) => {
+        ListItemComponent: (info: any) => any;
+        renderItem?: undefined;
+    } | {
+        ListItemComponent?: undefined;
+        renderItem: (info: any) => any;
+    }>;
+    render(): React.JSX.Element;
+}
+export { FlatList };
+export default FlatList;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/FlatList/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/FlatList/index.jsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAyD9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2GG;AACH,cAAM,QAAS,SAAQ,KAAK,CAAC,aAAa;IACxC;;OAEG;IACH,WAAW,CAAC,MAAM,KAAA,QAIjB;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,MAAM,KAAA,QAInB;IAED;;;;;OAKG;IACH,YAAY,CAAC,MAAM,KAAA,QAIlB;IAED;;;;OAIG;IACH,cAAc,CAAC,MAAM,KAAA,QAIpB;IAED;;;;OAIG;IACH,iBAAiB,SAIhB;IAED;;;;OAIG;IACH,qBAAqB,SAIpB;IAED;;OAEG;IACH,kBAAkB,QAIjB;IAED;;OAEG;IACH,kBAAkB,QAIjB;IAED,iBAAiB,QAIhB;IAED,YAAY,KAAK,KAAA,EAoBhB;IAED,kBAAkB,CAAC,SAAS,KAAA,QAqB3B;IAED,QAAQ,MAAA;IACR,qBAAqB,QAAK;IAE1B,WAAW,qBAEV;IAED,WAAW,CAAC,KAAK,KAAA,QAwBhB;IAED,QAAQ,iCAeP;IAED,aAAa,qBAaZ;IAED,aAAa,kCAiBZ;IAED,wBAAwB,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,QAQ9B;IAED,6BAA6B,CAAC,sBAAsB,KAAA,uBAiBnD;IAED,SAAS;;;;;;MA6CR;IAGD,iBAAiB;;;;;;OAA6B;IAE9C,MAAM,sBA6BL;CACF;AAMD,OAAO,EAAE,QAAQ,EAAE,CAAA;eACJ,QAAQ"}

package/types/vendor/react-native/JSEventLoopWatchdog/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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
+ * @format
+ */
+/**
+ * A utility for tracking stalls in the JS event loop that prevent timers and
+ * other events from being processed in a timely manner.
+ *
+ * The "stall" time is defined as the amount of time in access of the acceptable
+ * threshold, which is typically around 100-200ms. So if the treshold is set to
+ * 100 and a timer fires 150 ms later than it was scheduled because the event
+ * loop was tied up, that would be considered a 50ms stall.
+ *
+ * By default, logs stall events to the console when installed. Can also be
+ * queried with `getStats`.
+ */
+declare const JSEventLoopWatchdog: {
+    getStats: () => {
+        stallCount: number;
+        totalStallTime: number;
+        longestStall: number;
+        acceptableBusyTime: number;
+    };
+    reset: () => void;
+    addHandler: (handler: any) => void;
+    install: ({ thresholdMS }: {
+        thresholdMS: any;
+    }) => void;
+};
+export { JSEventLoopWatchdog };
+export default JSEventLoopWatchdog;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/JSEventLoopWatchdog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/JSEventLoopWatchdog/index.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;CA6CxB,CAAA;AAUD,OAAO,EAAE,mBAAmB,EAAE,CAAA;eACf,mBAAmB"}

package/types/vendor/react-native/LayoutAnimation/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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
+ * @format
+ */
+declare function configureNext(config: any, onAnimationDidEnd: any): void;
+declare function create(duration: any, type: any, property: any): {
+    duration: any;
+    create: {
+        type: any;
+        property: any;
+    };
+    update: {
+        type: any;
+    };
+    delete: {
+        type: any;
+        property: any;
+    };
+};
+/**
+ * Automatically animates views to their new positions when the
+ * next layout happens.
+ *
+ * A common way to use this API is to call it before calling `setState`.
+ *
+ * Note that in order to get this to work on **Android** you need to set the following flags via `UIManager`:
+ *
+ *     UIManager.setLayoutAnimationEnabledExperimental && UIManager.setLayoutAnimationEnabledExperimental(true);
+ */
+declare const LayoutAnimation: {
+    /**
+     * Schedules an animation to happen on the next layout.
+     *
+     * @param config Specifies animation properties:
+     *
+     *   - `duration` in milliseconds
+     *   - `create`, `AnimationConfig` for animating in new views
+     *   - `update`, `AnimationConfig` for animating views that have been updated
+     *
+     * @param onAnimationDidEnd Called when the animation finished.
+     * Only supported on iOS.
+     * @param onError Called on error. Only supported on iOS.
+     */
+    configureNext: typeof configureNext;
+    /**
+     * Helper for creating a config for `configureNext`.
+     */
+    create: typeof create;
+    Types: Readonly<{
+        spring: "spring";
+        linear: "linear";
+        easeInEaseOut: "easeInEaseOut";
+        easeIn: "easeIn";
+        easeOut: "easeOut";
+        keyboard: "keyboard";
+    }>;
+    Properties: Readonly<{
+        opacity: "opacity";
+        scaleX: "scaleX";
+        scaleY: "scaleY";
+        scaleXY: "scaleXY";
+    }>;
+    checkConfig(...args: any[]): void;
+    Presets: {
+        easeInEaseOut: {
+            duration: any;
+            create: {
+                type: any;
+                property: any;
+            };
+            update: {
+                type: any;
+            };
+            delete: {
+                type: any;
+                property: any;
+            };
+        };
+        linear: {
+            duration: any;
+            create: {
+                type: any;
+                property: any;
+            };
+            update: {
+                type: any;
+            };
+            delete: {
+                type: any;
+                property: any;
+            };
+        };
+        spring: {
+            duration: number;
+            create: {
+                type: string;
+                property: string;
+            };
+            update: {
+                type: string;
+                springDamping: number;
+            };
+            delete: {
+                type: string;
+                property: string;
+            };
+        };
+    };
+    easeInEaseOut: (onAnimationDidEnd?: any) => void;
+    linear: (onAnimationDidEnd?: any) => void;
+    spring: (onAnimationDidEnd?: any) => void;
+};
+export { LayoutAnimation };
+export default LayoutAnimation;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/LayoutAnimation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/LayoutAnimation/index.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkBH,iBAAS,aAAa,CAAC,MAAM,KAAA,EAAE,iBAAiB,KAAA,QAQ/C;AAED,iBAAS,MAAM,CAAC,QAAQ,KAAA,EAAE,IAAI,KAAA,EAAE,QAAQ,KAAA;;;;;;;;;;;;;EAOvC;AAsBD;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe;IACnB;;;;;;;;;;;;OAYG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA3CD,QAAQ;YACR,MAAM;gBACJ,IAAI;gBACJ,QAAQ;;YAEV,MAAM;gBACJ,IAAI;gBACJ,aAAa;;YAEf,MAAM;gBACJ,IAAI;gBACJ,QAAQ;;;;;;;CAuDb,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,CAAA;eACX,eAAe"}

package/types/vendor/react-native/PanResponder/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+declare const PanResponder: {
+    _initializeGestureState(gestureState: any): void;
+    _updateGestureStateOnMove(gestureState: any, touchHistory: any): void;
+    create(config: any): {
+        panHandlers: {
+            onStartShouldSetResponder(event: any): any;
+            onMoveShouldSetResponder(event: any): any;
+            onStartShouldSetResponderCapture(event: any): any;
+            onMoveShouldSetResponderCapture(event: any): any;
+            onResponderGrant(event: any): any;
+            onResponderReject(event: any): void;
+            onResponderRelease(event: any): void;
+            onResponderStart(event: any): void;
+            onResponderMove(event: any): void;
+            onResponderEnd(event: any): void;
+            onResponderTerminate(event: any): void;
+            onResponderTerminationRequest(event: any): any;
+            onClickCapture: (event: any) => void;
+        };
+        getInteractionHandle(): null;
+    };
+};
+export { PanResponder };
+export default PanResponder;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/PanResponder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/PanResponder/index.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgBH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;CAsMjB,CAAA;AAsBD,OAAO,EAAE,YAAY,EAAE,CAAA;eACR,YAAY"}

package/types/vendor/react-native/PooledClass/index.d.ts

@@ -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.
+ *
+ * From React 16.0.0
+ */
+declare var twoArgumentPooler: (a1: any, a2: any) => any;
+/**
+ * Augments `CopyConstructor` to be a poolable class, augmenting only the class
+ * itself (statically) not adding any prototypical fields. Any CopyConstructor
+ * you give this may have a `poolSize` property, and will look for a
+ * prototypical `destructor` on instances.
+ *
+ * @param {Function} CopyConstructor Constructor that can be used to reset.
+ * @param {Function} pooler Customizable pooler.
+ */
+declare var addPoolingTo: (CopyConstructor: Function, pooler: Function) => Function;
+declare var PooledClass: {
+    addPoolingTo: typeof addPoolingTo;
+    twoArgumentPooler: typeof twoArgumentPooler;
+};
+export { PooledClass };
+export default PooledClass;
+//# sourceMappingURL=index.d.ts.map

package/types/vendor/react-native/PooledClass/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/react-native/PooledClass/index.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,QAAA,IAAI,iBAAiB,2BASpB,CAAA;AAaD;;;;;;;;GAQG;AACH,QAAA,IAAI,YAAY,2DAWf,CAAA;AAED,QAAA,IAAI,WAAW;IACb,YAAY;IACZ,iBAAiB;CAClB,CAAA;AAED,OAAO,EAAE,WAAW,EAAE,CAAA;eACP,WAAW"}