yeet

node_modules/react-native/Libraries/Performance/NativeJSCSamplingProfiler.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 {TurboModule} from '../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +operationComplete: (token: number, result: ?string, error: ?string) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>('JSCSamplingProfiler'): ?Spec);

node_modules/react-native/Libraries/Performance/PureComponentDebug.js

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const React = require('react');
+
+opaque type DoNotCommitUsageOfPureComponentDebug = {...};
+
+/**
+ * Identifies which prop or state changes triggered a re-render of a PureComponent. Usage:
+ *
+ * Change `extends React.PureComponent` to `extends PureComponentDebug` or inject it
+ * everywhere by putting this line in your app setup:
+ *
+ *    React.PureComponent = require('PureComponentDebug');
+ *
+ * Should only be used for local testing, and will trigger a flow failure if you try to
+ * commit any usages.
+ */
+class PureComponentDebug<
+  P: DoNotCommitUsageOfPureComponentDebug,
+  S: ?Object = void,
+> extends React.Component<P, S> {
+  shouldComponentUpdate(nextProps: P, nextState: S): boolean {
+    const tag = this.constructor.name;
+    let ret = false;
+    const prevPropsKeys = Object.keys(this.props);
+    const nextPropsKeys = Object.keys(nextProps);
+    if (prevPropsKeys.length !== nextPropsKeys.length) {
+      ret = true;
+      console.warn(
+        'PureComponentDebug: different prop keys',
+        tag,
+        prevPropsKeys.filter(key => !nextPropsKeys.includes(key)),
+        nextPropsKeys.filter(key => !prevPropsKeys.includes(key)),
+      );
+    }
+    const prevStateKeys = Object.keys(this.state || {});
+    const nextStateKeys = Object.keys(nextState || {});
+    if (prevStateKeys.length !== nextStateKeys.length) {
+      ret = true;
+      console.warn(
+        'PureComponentDebug: different state keys',
+        tag,
+        prevStateKeys.filter(key => !nextStateKeys.includes(key)),
+        nextStateKeys.filter(key => !prevStateKeys.includes(key)),
+      );
+    }
+    for (const key in this.props) {
+      if (this.props[key] !== nextProps[key]) {
+        ret = true;
+        console.warn('PureComponentDebug: different prop values', tag, key);
+      }
+    }
+    for (const key in this.state) {
+      if (this.state[key] !== (nextState || {})[key]) {
+        ret = true;
+        console.warn('PureComponentDebug: different state values', tag, key);
+      }
+    }
+    return ret;
+  }
+}
+
+module.exports = PureComponentDebug;

node_modules/react-native/Libraries/Performance/QuickPerformanceLogger.js

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+'use strict';
+
+const AUTO_SET_TIMESTAMP = -1;
+const DUMMY_INSTANCE_KEY = 0;
+
+const QuickPerformanceLogger = {
+  markerStart(
+    markerId: number,
+    instanceKey: number = DUMMY_INSTANCE_KEY,
+    timestamp: number = AUTO_SET_TIMESTAMP,
+  ): void {
+    if (global.nativeQPLMarkerStart) {
+      global.nativeQPLMarkerStart(markerId, instanceKey, timestamp);
+    }
+  },
+
+  markerEnd(
+    markerId: number,
+    actionId: number,
+    instanceKey: number = DUMMY_INSTANCE_KEY,
+    timestamp: number = AUTO_SET_TIMESTAMP,
+  ): void {
+    if (global.nativeQPLMarkerEnd) {
+      global.nativeQPLMarkerEnd(markerId, instanceKey, actionId, timestamp);
+    }
+  },
+
+  markerTag(
+    markerId: number,
+    tag: string,
+    instanceKey: number = DUMMY_INSTANCE_KEY,
+  ): void {
+    if (global.nativeQPLMarkerTag) {
+      global.nativeQPLMarkerTag(markerId, instanceKey, tag);
+    }
+  },
+
+  markerAnnotate(
+    markerId: number,
+    annotationKey: string,
+    annotationValue: string,
+    instanceKey: number = DUMMY_INSTANCE_KEY,
+  ): void {
+    if (global.nativeQPLMarkerAnnotate) {
+      global.nativeQPLMarkerAnnotate(
+        markerId,
+        instanceKey,
+        annotationKey,
+        annotationValue,
+      );
+    }
+  },
+
+  markerCancel(
+    markerId: number,
+    instanceKey?: number = DUMMY_INSTANCE_KEY,
+  ): void {
+    if (global.nativeQPLMarkerCancel) {
+      global.nativeQPLMarkerCancel(markerId, instanceKey);
+    }
+  },
+
+  markerPoint(
+    markerId: number,
+    name: string,
+    instanceKey: number = DUMMY_INSTANCE_KEY,
+    timestamp: number = AUTO_SET_TIMESTAMP,
+  ): void {
+    if (global.nativeQPLMarkerPoint) {
+      global.nativeQPLMarkerPoint(markerId, name, instanceKey, timestamp);
+    }
+  },
+
+  markerDrop(
+    markerId: number,
+    instanceKey?: number = DUMMY_INSTANCE_KEY,
+  ): void {
+    if (global.nativeQPLMarkerDrop) {
+      global.nativeQPLMarkerDrop(markerId, instanceKey);
+    }
+  },
+
+  currentTimestamp(): number {
+    if (global.nativeQPLTimestamp) {
+      return global.nativeQPLTimestamp();
+    }
+    return 0;
+  },
+};
+
+module.exports = QuickPerformanceLogger;

node_modules/react-native/Libraries/Performance/SamplingProfiler.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 SamplingProfiler = {
+  poke: function(token: number): void {
+    let error = null;
+    let result = null;
+    try {
+      result = global.pokeSamplingProfiler();
+      if (result === null) {
+        console.log('The JSC Sampling Profiler has started');
+      } else {
+        console.log('The JSC Sampling Profiler has stopped');
+      }
+    } catch (e) {
+      console.log(
+        'Error occurred when restarting Sampling Profiler: ' + e.toString(),
+      );
+      error = e.toString();
+    }
+
+    const NativeJSCSamplingProfiler = require('./NativeJSCSamplingProfiler')
+      .default;
+    if (NativeJSCSamplingProfiler) {
+      NativeJSCSamplingProfiler.operationComplete(token, result, error);
+    }
+  },
+};
+
+module.exports = SamplingProfiler;

node_modules/react-native/Libraries/Performance/Systrace.js

@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+const invariant = require('invariant');
+
+const TRACE_TAG_REACT_APPS = 1 << 17; // eslint-disable-line no-bitwise
+const TRACE_TAG_JS_VM_CALLS = 1 << 27; // eslint-disable-line no-bitwise
+
+let _enabled = false;
+let _asyncCookie = 0;
+const _markStack = [];
+let _markStackIndex = -1;
+let _canInstallReactHook = false;
+
+// Implements a subset of User Timing API necessary for React measurements.
+// https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
+const REACT_MARKER = '\u269B';
+const userTimingPolyfill = __DEV__
+  ? {
+      mark(markName: string) {
+        if (_enabled) {
+          _markStackIndex++;
+          _markStack[_markStackIndex] = markName;
+          let systraceLabel = markName;
+          // Since perf measurements are a shared namespace in User Timing API,
+          // we prefix all React results with a React emoji.
+          if (markName[0] === REACT_MARKER) {
+            // This is coming from React.
+            // Removing component IDs keeps trace colors stable.
+            const indexOfId = markName.lastIndexOf(' (#');
+            const cutoffIndex = indexOfId !== -1 ? indexOfId : markName.length;
+            // Also cut off the emoji because it breaks Systrace
+            systraceLabel = markName.slice(2, cutoffIndex);
+          }
+          Systrace.beginEvent(systraceLabel);
+        }
+      },
+      measure(measureName: string, startMark: ?string, endMark: ?string) {
+        if (_enabled) {
+          invariant(
+            typeof measureName === 'string' &&
+              typeof startMark === 'string' &&
+              typeof endMark === 'undefined',
+            'Only performance.measure(string, string) overload is supported.',
+          );
+          const topMark = _markStack[_markStackIndex];
+          invariant(
+            startMark === topMark,
+            'There was a mismatching performance.measure() call. ' +
+              'Expected "%s" but got "%s."',
+            topMark,
+            startMark,
+          );
+          _markStackIndex--;
+          // We can't use more descriptive measureName because Systrace doesn't
+          // let us edit labels post factum.
+          Systrace.endEvent();
+        }
+      },
+      clearMarks(markName: string) {
+        if (_enabled) {
+          if (_markStackIndex === -1) {
+            return;
+          }
+          if (markName === _markStack[_markStackIndex]) {
+            // React uses this for "cancelling" started measurements.
+            // Systrace doesn't support deleting measurements, so we just stop them.
+            if (userTimingPolyfill != null) {
+              userTimingPolyfill.measure(markName, markName);
+            }
+          }
+        }
+      },
+      clearMeasures() {
+        // React calls this to avoid memory leaks in browsers, but we don't keep
+        // measurements anyway.
+      },
+    }
+  : null;
+
+function installPerformanceHooks(polyfill) {
+  if (polyfill) {
+    if (global.performance === undefined) {
+      global.performance = {};
+    }
+
+    Object.keys(polyfill).forEach(methodName => {
+      if (typeof global.performance[methodName] !== 'function') {
+        global.performance[methodName] = polyfill[methodName];
+      }
+    });
+  }
+}
+
+const Systrace = {
+  installReactHook() {
+    if (_enabled) {
+      if (__DEV__) {
+        installPerformanceHooks(userTimingPolyfill);
+      }
+    }
+    _canInstallReactHook = true;
+  },
+
+  setEnabled(enabled: boolean) {
+    if (_enabled !== enabled) {
+      if (__DEV__) {
+        if (enabled) {
+          global.nativeTraceBeginLegacy &&
+            global.nativeTraceBeginLegacy(TRACE_TAG_JS_VM_CALLS);
+        } else {
+          global.nativeTraceEndLegacy &&
+            global.nativeTraceEndLegacy(TRACE_TAG_JS_VM_CALLS);
+        }
+        if (_canInstallReactHook) {
+          if (enabled) {
+            installPerformanceHooks(userTimingPolyfill);
+          }
+        }
+      }
+      _enabled = enabled;
+    }
+  },
+
+  isEnabled(): boolean {
+    return _enabled;
+  },
+
+  /**
+   * beginEvent/endEvent for starting and then ending a profile within the same call stack frame
+   **/
+  beginEvent(profileName?: any, args?: any) {
+    if (_enabled) {
+      profileName =
+        typeof profileName === 'function' ? profileName() : profileName;
+      global.nativeTraceBeginSection(TRACE_TAG_REACT_APPS, profileName, args);
+    }
+  },
+
+  endEvent() {
+    if (_enabled) {
+      global.nativeTraceEndSection(TRACE_TAG_REACT_APPS);
+    }
+  },
+
+  /**
+   * beginAsyncEvent/endAsyncEvent for starting and then ending a profile where the end can either
+   * occur on another thread or out of the current stack frame, eg await
+   * the returned cookie variable should be used as input into the endAsyncEvent call to end the profile
+   **/
+  beginAsyncEvent(profileName?: any): any {
+    const cookie = _asyncCookie;
+    if (_enabled) {
+      _asyncCookie++;
+      profileName =
+        typeof profileName === 'function' ? profileName() : profileName;
+      global.nativeTraceBeginAsyncSection(
+        TRACE_TAG_REACT_APPS,
+        profileName,
+        cookie,
+      );
+    }
+    return cookie;
+  },
+
+  endAsyncEvent(profileName?: any, cookie?: any) {
+    if (_enabled) {
+      profileName =
+        typeof profileName === 'function' ? profileName() : profileName;
+      global.nativeTraceEndAsyncSection(
+        TRACE_TAG_REACT_APPS,
+        profileName,
+        cookie,
+      );
+    }
+  },
+
+  /**
+   * counterEvent registers the value to the profileName on the systrace timeline
+   **/
+  counterEvent(profileName?: any, value?: any) {
+    if (_enabled) {
+      profileName =
+        typeof profileName === 'function' ? profileName() : profileName;
+      global.nativeTraceCounter &&
+        global.nativeTraceCounter(TRACE_TAG_REACT_APPS, profileName, value);
+    }
+  },
+};
+
+if (__DEV__) {
+  // This is needed, because require callis in polyfills are not processed as
+  // other files. Therefore, calls to `require('moduleId')` are not replaced
+  // with numeric IDs
+  // TODO(davidaurelio) Scan polyfills for dependencies, too (t9759686)
+  (require: any).Systrace = Systrace;
+}
+
+module.exports = Systrace;