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

package/src/vendor/react-native/JSEventLoopWatchdog/index.js

@@ -0,0 +1,87 @@
+/**
+ * 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 infoLog from '../infoLog';
+
+type Handler = {
+  onIterate?: () => void,
+  onStall: (params: {lastInterval: number, busyTime: number}) => ?string,
+};
+
+/**
+ * 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`.
+ */
+const JSEventLoopWatchdog = {
+  getStats: function(): Object {
+    return {stallCount, totalStallTime, longestStall, acceptableBusyTime};
+  },
+  reset: function() {
+    infoLog('JSEventLoopWatchdog: reset');
+    totalStallTime = 0;
+    stallCount = 0;
+    longestStall = 0;
+    lastInterval = window.performance.now();
+  },
+  addHandler: function(handler: Handler) {
+    handlers.push(handler);
+  },
+  install: function({thresholdMS}: {thresholdMS: number}) {
+    acceptableBusyTime = thresholdMS;
+    if (installed) {
+      return;
+    }
+    installed = true;
+    lastInterval = window.performance.now();
+    function iteration() {
+      const now = window.performance.now();
+      const busyTime = now - lastInterval;
+      if (busyTime >= thresholdMS) {
+        const stallTime = busyTime - thresholdMS;
+        stallCount++;
+        totalStallTime += stallTime;
+        longestStall = Math.max(longestStall, stallTime);
+        let msg =
+          `JSEventLoopWatchdog: JS thread busy for ${busyTime}ms. ` +
+          `${totalStallTime}ms in ${stallCount} stalls so far. `;
+        handlers.forEach(handler => {
+          msg += handler.onStall({lastInterval, busyTime}) || '';
+        });
+        infoLog(msg);
+      }
+      handlers.forEach(handler => {
+        handler.onIterate && handler.onIterate();
+      });
+      lastInterval = now;
+      setTimeout(iteration, thresholdMS / 5);
+    }
+    iteration();
+  },
+};
+
+let acceptableBusyTime = 0;
+let installed = false;
+let totalStallTime = 0;
+let stallCount = 0;
+let longestStall = 0;
+let lastInterval = 0;
+const handlers: Array<Handler> = [];
+
+export default JSEventLoopWatchdog;

package/src/vendor/react-native/LayoutAnimation/index.js

@@ -0,0 +1,142 @@
+/**
+ * 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 Platform from '../../../exports/Platform';
+import UIManager from '../../../exports/UIManager';
+
+const __DEV__ = process.env.NODE_ENV !== 'production';
+
+type Type =
+  | 'spring'
+  | 'linear'
+  | 'easeInEaseOut'
+  | 'easeIn'
+  | 'easeOut'
+  | 'keyboard';
+
+type Property = 'opacity' | 'scaleX' | 'scaleY' | 'scaleXY';
+
+type AnimationConfig = $ReadOnly<{|
+  duration?: number,
+  delay?: number,
+  springDamping?: number,
+  initialVelocity?: number,
+  type?: Type,
+  property?: Property,
+|}>;
+
+type LayoutAnimationConfig = $ReadOnly<{|
+  duration: number,
+  create?: AnimationConfig,
+  update?: AnimationConfig,
+  delete?: AnimationConfig,
+|}>;
+
+function configureNext(
+  config: LayoutAnimationConfig,
+  onAnimationDidEnd?: Function,
+) {
+  if (!Platform.isTesting) {
+    UIManager.configureNextLayoutAnimation(
+      config,
+      onAnimationDidEnd ?? function() {},
+      function() {} /* unused onError */,
+    );
+  }
+}
+
+function create(
+  duration: number,
+  type: Type,
+  property: Property,
+): LayoutAnimationConfig {
+  return {
+    duration,
+    create: {type, property},
+    update: {type},
+    delete: {type, property},
+  };
+}
+
+const Presets = {
+  easeInEaseOut: (create(300, 'easeInEaseOut', 'opacity'): LayoutAnimationConfig),
+  linear: (create(500, 'linear', 'opacity'): LayoutAnimationConfig),
+  spring: {
+    duration: 700,
+    create: {
+      type: 'linear',
+      property: 'opacity',
+    },
+    update: {
+      type: 'spring',
+      springDamping: 0.4,
+    },
+    delete: {
+      type: 'linear',
+      property: 'opacity',
+    },
+  },
+};
+
+/**
+ * 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);
+ */
+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,
+  /**
+   * Helper for creating a config for `configureNext`.
+   */
+  create,
+  Types: Object.freeze({
+    spring: 'spring',
+    linear: 'linear',
+    easeInEaseOut: 'easeInEaseOut',
+    easeIn: 'easeIn',
+    easeOut: 'easeOut',
+    keyboard: 'keyboard',
+  }),
+  Properties: Object.freeze({
+    opacity: 'opacity',
+    scaleX: 'scaleX',
+    scaleY: 'scaleY',
+    scaleXY: 'scaleXY',
+  }),
+  checkConfig(...args: Array<mixed>) {
+    console.error('LayoutAnimation.checkConfig(...) has been disabled.');
+  },
+  Presets,
+  easeInEaseOut: (configureNext.bind(null, Presets.easeInEaseOut): (onAnimationDidEnd?: any) => void),
+  linear: (configureNext.bind(null, Presets.linear): (onAnimationDidEnd?: any) => void),
+  spring: (configureNext.bind(null, Presets.spring): (onAnimationDidEnd?: any) => void),
+};
+
+export default LayoutAnimation;