@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/vendor/react-native/Animated/nodes/AnimatedWithChildren.js

@@ -0,0 +1,73 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import _createForOfIteratorHelperLoose from "@babel/runtime/helpers/createForOfIteratorHelperLoose";
+import AnimatedNode from './AnimatedNode';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+class AnimatedWithChildren extends AnimatedNode {
+  constructor() {
+    super();
+    this._children = [];
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (var _iterator = _createForOfIteratorHelperLoose(this._children), _step; !(_step = _iterator()).done;) {
+        var child = _step.value;
+        child.__makeNative(platformConfig);
+        NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+      }
+    }
+    super.__makeNative(platformConfig);
+  }
+  __addChild(child) {
+    if (this._children.length === 0) {
+      this.__attach();
+    }
+    this._children.push(child);
+    if (this.__isNative) {
+      // Only accept "native" animated nodes as children
+      child.__makeNative(this.__getPlatformConfig());
+      NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+  }
+  __removeChild(child) {
+    var index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    if (this.__isNative && child.__isNative) {
+      NativeAnimatedHelper.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+    this._children.splice(index, 1);
+    if (this._children.length === 0) {
+      this.__detach();
+    }
+  }
+  __getChildren() {
+    return this._children;
+  }
+  __callListeners(value) {
+    super.__callListeners(value);
+    if (!this.__isNative) {
+      for (var _iterator2 = _createForOfIteratorHelperLoose(this._children), _step2; !(_step2 = _iterator2()).done;) {
+        var child = _step2.value;
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        if (child.__getValue) {
+          child.__callListeners(child.__getValue());
+        }
+      }
+    }
+  }
+}
+export default AnimatedWithChildren;

package/dist/vendor/react-native/Animated/nodes/AnimatedWithChildren.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import type { PlatformConfig } from '../AnimatedPlatformConfig';
+import AnimatedNode from './AnimatedNode';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+declare class AnimatedWithChildren extends AnimatedNode {
+  _children: Array<AnimatedNode>,
+  constructor(): any,
+  __makeNative(platformConfig: ?PlatformConfig): any,
+  __addChild(child: AnimatedNode): void,
+  __removeChild(child: AnimatedNode): void,
+  __getChildren(): Array<AnimatedNode>,
+  __callListeners(value: number): void,
+}
+export default AnimatedWithChildren;

package/dist/vendor/react-native/Animated/useAnimatedProps.js

@@ -0,0 +1,154 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import AnimatedProps from './nodes/AnimatedProps';
+import { AnimatedEvent } from './AnimatedEvent';
+import useRefEffect from '../Utilities/useRefEffect';
+import NativeAnimatedHelper from './NativeAnimatedHelper';
+import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+import useLayoutEffect from '../../../modules/useLayoutEffect';
+export default function useAnimatedProps(props) {
+  var _useReducer = useReducer(count => count + 1, 0),
+    scheduleUpdate = _useReducer[1];
+  var onUpdateRef = useRef(null);
+
+  // TODO: Only invalidate `node` if animated props or `style` change. In the
+  // previous implementation, we permitted `style` to override props with the
+  // same name property name as styles, so we can probably continue doing that.
+  // The ordering of other props *should* not matter.
+  var node = useMemo(() => new AnimatedProps(props, () => onUpdateRef.current == null ? void 0 : onUpdateRef.current()), [props]);
+  useAnimatedPropsLifecycle(node);
+
+  // TODO: This "effect" does three things:
+  //
+  //   1) Call `setNativeView`.
+  //   2) Update `onUpdateRef`.
+  //   3) Update listeners for `AnimatedEvent` props.
+  //
+  // Ideally, each of these would be separat "effects" so that they are not
+  // unnecessarily re-run when irrelevant dependencies change. For example, we
+  // should be able to hoist all `AnimatedEvent` props and only do #3 if either
+  // the `AnimatedEvent` props change or `instance` changes.
+  //
+  // But there is no way to transparently compose three separate callback refs,
+  // so we just combine them all into one for now.
+  var refEffect = useCallback(instance => {
+    // NOTE: This may be called more often than necessary (e.g. when `props`
+    // changes), but `setNativeView` already optimizes for that.
+    node.setNativeView(instance);
+
+    // NOTE: This callback is only used by the JavaScript animation driver.
+    onUpdateRef.current = () => {
+      // Schedule an update for this component to update `reducedProps`,
+      // but do not compute it immediately. If a parent also updated, we
+      // need to merge those new props in before updating.
+      scheduleUpdate();
+    };
+    var target = getEventTarget(instance);
+    var events = [];
+    for (var propName in props) {
+      var propValue = props[propName];
+      if (propValue instanceof AnimatedEvent && propValue.__isNative) {
+        propValue.__attach(target, propName);
+        events.push([propName, propValue]);
+      }
+    }
+    return () => {
+      onUpdateRef.current = null;
+      for (var _i = 0, _events = events; _i < _events.length; _i++) {
+        var _events$_i = _events[_i],
+          _propName = _events$_i[0],
+          _propValue = _events$_i[1];
+        _propValue.__detach(target, _propName);
+      }
+    };
+  }, [props, node]);
+  var callbackRef = useRefEffect(refEffect);
+  return [reduceAnimatedProps(node), callbackRef];
+}
+function reduceAnimatedProps(node) {
+  // Force `collapsable` to be false so that the native view is not flattened.
+  // Flattened views cannot be accurately referenced by the native driver.
+  return _objectSpread(_objectSpread({}, node.__getValue()), {}, {
+    collapsable: false
+  });
+}
+
+/**
+ * Manages the lifecycle of the supplied `AnimatedProps` by invoking `__attach`
+ * and `__detach`. However, this is more complicated because `AnimatedProps`
+ * uses reference counting to determine when to recursively detach its children
+ * nodes. So in order to optimize this, we avoid detaching until the next attach
+ * unless we are unmounting.
+ */
+function useAnimatedPropsLifecycle(node) {
+  var prevNodeRef = useRef(null);
+  var isUnmountingRef = useRef(false);
+  useEffect(() => {
+    // It is ok for multiple components to call `flushQueue` because it noops
+    // if the queue is empty. When multiple animated components are mounted at
+    // the same time. Only first component flushes the queue and the others will noop.
+    NativeAnimatedHelper.API.flushQueue();
+  });
+  useLayoutEffect(() => {
+    isUnmountingRef.current = false;
+    return () => {
+      isUnmountingRef.current = true;
+    };
+  }, []);
+  useLayoutEffect(() => {
+    node.__attach();
+    if (prevNodeRef.current != null) {
+      var prevNode = prevNodeRef.current;
+      // TODO: Stop restoring default values (unless `reset` is called).
+      prevNode.__restoreDefaultValues();
+      prevNode.__detach();
+      prevNodeRef.current = null;
+    }
+    return () => {
+      if (isUnmountingRef.current) {
+        // NOTE: Do not restore default values on unmount, see D18197735.
+        node.__detach();
+      } else {
+        prevNodeRef.current = node;
+      }
+    };
+  }, [node]);
+}
+function getEventTarget(instance) {
+  return typeof instance === 'object' && typeof (instance == null ? void 0 : instance.getScrollableNode) === 'function' ?
+  // $FlowFixMe[incompatible-use] - Legacy instance assumptions.
+  instance.getScrollableNode() : instance;
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function isFabricInstance(instance) {
+  var _instance$getScrollRe;
+  return hasFabricHandle(instance) ||
+  // Some components have a setNativeProps function but aren't a host component
+  // such as lists like FlatList and SectionList. These should also use
+  // forceUpdate in Fabric since setNativeProps doesn't exist on the underlying
+  // host component. This crazy hack is essentially special casing those lists and
+  // ScrollView itself to use forceUpdate in Fabric.
+  // If these components end up using forwardRef then these hacks can go away
+  // as instance would actually be the underlying host component and the above check
+  // would be sufficient.
+  hasFabricHandle(instance == null || instance.getNativeScrollRef == null ? void 0 : instance.getNativeScrollRef()) || hasFabricHandle(instance == null || instance.getScrollResponder == null || (_instance$getScrollRe = instance.getScrollResponder()) == null || _instance$getScrollRe.getNativeScrollRef == null ? void 0 : _instance$getScrollRe.getNativeScrollRef());
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function hasFabricHandle(instance) {
+  var _instance$_internalIn;
+  // eslint-disable-next-line dot-notation
+  return (instance == null || (_instance$_internalIn = instance['_internalInstanceHandle']) == null || (_instance$_internalIn = _instance$_internalIn.stateNode) == null ? void 0 : _instance$_internalIn.canonical) != null;
+}

package/dist/vendor/react-native/Animated/useAnimatedProps.js.flow

@@ -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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import AnimatedProps from './nodes/AnimatedProps';
+import { AnimatedEvent } from './AnimatedEvent';
+import useRefEffect from '../Utilities/useRefEffect';
+import NativeAnimatedHelper from './NativeAnimatedHelper';
+import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+import useLayoutEffect from '../../../modules/useLayoutEffect';
+type ReducedProps<TProps> = {
+  ...TProps,
+  collapsable: boolean,
+  ...
+};
+type CallbackRef<T> = (T) => mixed;
+declare export default function useAnimatedProps<TProps: {...}, TInstance>(props: TProps): [ReducedProps<TProps>, CallbackRef<TInstance | null>];
+declare function reduceAnimatedProps<TProps>(node: AnimatedProps): ReducedProps<TProps>;
+/**
+ * Manages the lifecycle of the supplied `AnimatedProps` by invoking `__attach`
+ * and `__detach`. However, this is more complicated because `AnimatedProps`
+ * uses reference counting to determine when to recursively detach its children
+ * nodes. So in order to optimize this, we avoid detaching until the next attach
+ * unless we are unmounting.
+ */
+declare function useAnimatedPropsLifecycle(node: AnimatedProps): void;
+declare function getEventTarget<TInstance>(instance: TInstance): TInstance; // $FlowFixMe[unclear-type] - Legacy instance assumptions.
+declare function isFabricInstance(instance: any): boolean; // $FlowFixMe[unclear-type] - Legacy instance assumptions.
+declare function hasFabricHandle(instance: any): boolean;

package/dist/vendor/react-native/Batchinator/index.js

@@ -0,0 +1,79 @@
+/**
+ * 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
+ * 
+ */
+
+'use strict';
+
+import InteractionManager from '../../../exports/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 {
+  constructor(callback, delayMS) {
+    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) {
+    if (options === void 0) {
+      options = {
+        abort: false
+      };
+    }
+    if (this._taskHandle) {
+      this._taskHandle.cancel();
+      if (!options.abort) {
+        this._callback();
+      }
+      this._taskHandle = null;
+    }
+  }
+  schedule() {
+    if (this._taskHandle) {
+      return;
+    }
+    var 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)
+    };
+  }
+}
+export default Batchinator;

package/dist/vendor/react-native/Batchinator/index.js.flow

@@ -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
+ * @flow strict-local
+ */
+
+'use strict';
+
+import InteractionManager from '../../../exports/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();
+ *     }
+ *     ...
+ *   }
+ */
+declare class Batchinator {
+  _callback: () => void,
+  _delay: number,
+  _taskHandle: ?{
+    cancel: () => void,
+    ...
+  },
+  constructor(callback: () => void, delayMS: number): any,
+  dispose(options: {
+    abort: boolean,
+    ...
+  }): any,
+  schedule(): any,
+}
+export default Batchinator;

package/dist/vendor/react-native/EventEmitter/NativeEventEmitter.js

@@ -0,0 +1,80 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import Platform from '../../../exports/Platform';
+import RCTDeviceEventEmitter from './RCTDeviceEventEmitter';
+import invariant from 'fbjs/lib/invariant';
+/**
+ * `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).
+ */
+export default class NativeEventEmitter {
+  constructor(nativeModule) {
+    if (Platform.OS === 'ios' || Platform.OS === 'web') {
+      // Avoiding this check for web as there are 3rd party modules for web which are failing for this
+      if (Platform.OS === 'ios') {
+        invariant(nativeModule != null, '`new NativeEventEmitter()` requires a non-null argument.');
+      }
+      this._nativeModule = nativeModule;
+    }
+  }
+  addListener(eventType, listener, context) {
+    var _this$_nativeModule;
+    (_this$_nativeModule = this._nativeModule) == null || _this$_nativeModule.addListener(eventType);
+    var subscription = RCTDeviceEventEmitter.addListener(eventType, listener, context);
+    return {
+      remove: () => {
+        if (subscription != null) {
+          var _this$_nativeModule2;
+          (_this$_nativeModule2 = this._nativeModule) == null || _this$_nativeModule2.removeListeners(1);
+          // $FlowFixMe[incompatible-use]
+          subscription.remove();
+          subscription = null;
+        }
+      }
+    };
+  }
+
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeListener(eventType, listener) {
+    var _this$_nativeModule3;
+    (_this$_nativeModule3 = this._nativeModule) == null || _this$_nativeModule3.removeListeners(1);
+    // NOTE: This will report a deprecation notice via `console.error`.
+    // $FlowFixMe[prop-missing] - `removeListener` exists but is deprecated.
+    RCTDeviceEventEmitter.removeListener(eventType, listener);
+  }
+  emit(eventType) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    // Generally, `RCTDeviceEventEmitter` is directly invoked. But this is
+    // included for completeness.
+    RCTDeviceEventEmitter.emit(eventType, ...args);
+  }
+  removeAllListeners(eventType) {
+    var _this$_nativeModule4;
+    invariant(eventType != null, '`NativeEventEmitter.removeAllListener()` requires a non-null argument.');
+    (_this$_nativeModule4 = this._nativeModule) == null || _this$_nativeModule4.removeListeners(this.listenerCount(eventType));
+    RCTDeviceEventEmitter.removeAllListeners(eventType);
+  }
+  listenerCount(eventType) {
+    return RCTDeviceEventEmitter.listenerCount(eventType);
+  }
+}

package/dist/vendor/react-native/EventEmitter/NativeEventEmitter.js.flow

@@ -0,0 +1,42 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import { type EventSubscription, type IEventEmitter } from '../vendor/emitter/EventEmitter';
+import Platform from '../../../exports/Platform';
+import RCTDeviceEventEmitter from './RCTDeviceEventEmitter';
+import invariant from 'fbjs/lib/invariant';
+type NativeModule = $ReadOnly<{
+  addListener: (eventType: string) => void,
+  removeListeners: (count: number) => void,
+  ...
+}>;
+export type { EventSubscription };
+
+/**
+ * `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 export default class NativeEventEmitter<TEventToArgsMap: {...}> implements IEventEmitter<TEventToArgsMap> {
+  _nativeModule: ?NativeModule,
+  constructor(nativeModule: ?NativeModule): any,
+  addListener<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed, context?: mixed): EventSubscription,
+  removeListener<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed): void,
+  emit<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, ...args: $ElementType<TEventToArgsMap, TEvent>): void,
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void,
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number,
+}

package/dist/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.js

@@ -0,0 +1,21 @@
+/**
+ * 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 '../vendor/emitter/EventEmitter';
+
+// FIXME: use typed events
+
+/**
+ * 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`.
+ */
+export default new EventEmitter();

package/dist/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.js.flow

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import EventEmitter, { type IEventEmitter } from '../vendor/emitter/EventEmitter';
+
+// FIXME: use typed events
+type RCTDeviceEventDefinitions = $FlowFixMe;
+
+/**
+ * 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`.
+ */
+export default (new EventEmitter(): IEventEmitter<RCTDeviceEventDefinitions>);