@office-iss/react-native-win32 0.0.0-canary.30 → 0.0.0-canary.301

package/Libraries/Network/XMLHttpRequest.js

@@ -1,25 +1,46 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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
+ * @format
  */
 
 'use strict';
 
-const BlobManager = require('../Blob/BlobManager');
-const EventTarget = require('event-target-shim');
-const GlobalPerformanceLogger = require('react-native/Libraries/Utilities/GlobalPerformanceLogger');
-const RCTNetworking = require('./RCTNetworking');
-
+import type {
+  EventCallback,
+  EventListener,
+} from '../../src/private/webapis/dom/events/EventTarget';
+import type Performance from '../../src/private/webapis/performance/Performance';
+import type {IPerformanceLogger} from '../Utilities/createPerformanceLogger';
+
+import Event from '../../src/private/webapis/dom/events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../../src/private/webapis/dom/events/EventHandlerAttributes';
+import EventTarget from '../../src/private/webapis/dom/events/EventTarget';
+import {dispatchTrustedEvent} from '../../src/private/webapis/dom/events/internals/EventTargetInternals';
+import ProgressEvent from '../../src/private/webapis/xhr/events/ProgressEvent';
+import {type EventSubscription} from '../vendor/emitter/EventEmitter';
+
+const BlobManager = require('../Blob/BlobManager').default;
+const GlobalPerformanceLogger =
+  require('../Utilities/GlobalPerformanceLogger').default;
+const RCTNetworking = require('./RCTNetworking').default;
 const base64 = require('base64-js');
 const invariant = require('invariant');
-const warning = require('fbjs/lib/warning');
+
+const PERFORMANCE_TRACK_NAME = 'Network (JS-initiated only)';
+const PERFORMANCE_TRACK_GROUP = 'Chrome DevTools Temp Compat';
+
+declare var performance: Performance;
 
 const DEBUG_NETWORK_SEND_DELAY: false = false; // Set to a number of milliseconds when debugging
+const LABEL_FOR_MISSING_URL_FOR_PROFILING = 'Unknown URL';
 
 export type NativeResponseType = 'base64' | 'blob' | 'text';
 export type ResponseType =
@@ -31,7 +52,7 @@ export type ResponseType =
   | 'text';
 export type Response = ?Object | string;
 
-type XHRInterceptor = {
+type XHRInterceptor = interface {
   requestSent(id: number, url: string, method: string, headers: Object): void,
   responseReceived(
     id: number,
@@ -42,7 +63,6 @@ type XHRInterceptor = {
   dataReceived(id: number, data: string): void,
   loadingFinished(id: number, encodedDataLength: number): void,
   loadingFailed(id: number, error: string): void,
-  ...
 };
 
 // The native blob module is optional so inject it here if available.
@@ -65,32 +85,55 @@ const SUPPORTED_RESPONSE_TYPES = {
   '': true,
 };
 
-const REQUEST_EVENTS = [
-  'abort',
-  'error',
-  'load',
-  'loadstart',
-  'progress',
-  'timeout',
-  'loadend',
-];
-
-const XHR_EVENTS = REQUEST_EVENTS.concat('readystatechange');
-
-class XMLHttpRequestEventTarget extends (EventTarget(...REQUEST_EVENTS): any) {
-  onload: ?Function;
-  onloadstart: ?Function;
-  onprogress: ?Function;
-  ontimeout: ?Function;
-  onerror: ?Function;
-  onabort: ?Function;
-  onloadend: ?Function;
+class XMLHttpRequestEventTarget extends EventTarget {
+  get onload(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'load');
+  }
+  set onload(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'load', listener);
+  }
+  get onloadstart(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadstart');
+  }
+  set onloadstart(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadstart', listener);
+  }
+  get onprogress(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'progress');
+  }
+  set onprogress(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'progress', listener);
+  }
+  get ontimeout(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'timeout');
+  }
+  set ontimeout(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'timeout', listener);
+  }
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+  get onabort(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'abort');
+  }
+  set onabort(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'abort', listener);
+  }
+  get onloadend(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadend');
+  }
+  set onloadend(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadend', listener);
+  }
 }
 
 /**
  * Shared base for platform-specific XMLHttpRequest implementations.
  */
-class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
+class XMLHttpRequest extends EventTarget {
   static UNSENT: number = UNSENT;
   static OPENED: number = OPENED;
   static HEADERS_RECEIVED: number = HEADERS_RECEIVED;
@@ -98,6 +141,7 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   static DONE: number = DONE;
 
   static _interceptor: ?XHRInterceptor = null;
+  static _profiling: boolean = false;
 
   UNSENT: number = UNSENT;
   OPENED: number = OPENED;
@@ -105,16 +149,6 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   LOADING: number = LOADING;
   DONE: number = DONE;
 
-  // EventTarget automatically initializes these to `null`.
-  onload: ?Function;
-  onloadstart: ?Function;
-  onprogress: ?Function;
-  ontimeout: ?Function;
-  onerror: ?Function;
-  onabort: ?Function;
-  onloadend: ?Function;
-  onreadystatechange: ?Function;
-
   readyState: number = UNSENT;
   responseHeaders: ?Object;
   status: number = 0;
@@ -125,7 +159,7 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   upload: XMLHttpRequestEventTarget = new XMLHttpRequestEventTarget();
 
   _requestId: ?number;
-  _subscriptions: Array<*>;
+  _subscriptions: Array<EventSubscription>;
 
   _aborted: boolean = false;
   _cachedResponse: Response;
@@ -134,19 +168,24 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   _lowerCaseResponseHeaders: Object;
   _method: ?string = null;
   _perfKey: ?string = null;
-  _response: string | ?Object;
   _responseType: ResponseType;
   _response: string = '';
   _sent: boolean;
   _url: ?string = null;
   _timedOut: boolean = false;
-  _trackingName: string = 'unknown';
+  _trackingName: ?string;
   _incrementalEvents: boolean = false;
+  _startTime: ?number = null;
+  _performanceLogger: IPerformanceLogger = GlobalPerformanceLogger;
 
-  static setInterceptor(interceptor: ?XHRInterceptor) {
+  static __setInterceptor_DO_NOT_USE(interceptor: ?XHRInterceptor) {
     XMLHttpRequest._interceptor = interceptor;
   }
 
+  static enableProfiling(enableProfiling: boolean): void {
+    XMLHttpRequest._profiling = enableProfiling;
+  }
+
   constructor() {
     super();
     this._reset();
@@ -184,8 +223,7 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
       );
     }
     if (!SUPPORTED_RESPONSE_TYPES.hasOwnProperty(responseType)) {
-      warning(
-        false,
+      console.warn(
         `The provided value '${responseType}' is not a valid 'responseType'.`,
       );
       return;
@@ -248,7 +286,10 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
         } else if (this._response === '') {
           this._cachedResponse = BlobManager.createFromParts([]);
         } else {
-          throw new Error(`Invalid response for blob: ${this._response}`);
+          throw new Error(
+            'Invalid response for blob - expecting object, was ' +
+              `${typeof this._response}: ${this._response.trim()}`,
+          );
         }
         break;
 
@@ -287,12 +328,14 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
     total: number,
   ): void {
     if (requestId === this._requestId) {
-      this.upload.dispatchEvent({
-        type: 'progress',
-        lengthComputable: true,
-        loaded: progress,
-        total,
-      });
+      dispatchTrustedEvent(
+        this.upload,
+        new ProgressEvent('progress', {
+          lengthComputable: true,
+          loaded: progress,
+          total,
+        }),
+      );
     }
   }
 
@@ -304,7 +347,7 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   ): void {
     if (requestId === this._requestId) {
       this._perfKey != null &&
-        GlobalPerformanceLogger.stopTimespan(this._perfKey);
+        this._performanceLogger.stopTimespan(this._perfKey);
       this.status = status;
       this.setResponseHeaders(responseHeaders);
       this.setReadyState(this.HEADERS_RECEIVED);
@@ -345,12 +388,24 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
     if (requestId !== this._requestId) {
       return;
     }
+
+    const start = XMLHttpRequest._profiling ? performance.now() : undefined;
+
     if (!this._response) {
       this._response = responseText;
     } else {
       this._response += responseText;
     }
 
+    if (XMLHttpRequest._profiling) {
+      console.timeStamp(
+        'Incremental Data: ' + this._getMeasureURL(),
+        start,
+        undefined,
+        PERFORMANCE_TRACK_NAME,
+        PERFORMANCE_TRACK_GROUP,
+      );
+    }
     XMLHttpRequest._interceptor &&
       XMLHttpRequest._interceptor.dataReceived(requestId, responseText);
 
@@ -366,12 +421,14 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
     if (requestId !== this._requestId) {
       return;
     }
-    this.dispatchEvent({
-      type: 'progress',
-      lengthComputable: total >= 0,
-      loaded,
-      total,
-    });
+    dispatchTrustedEvent(
+      this,
+      new ProgressEvent('progress', {
+        lengthComputable: total >= 0,
+        loaded,
+        total,
+      }),
+    );
   }
 
   // exposed for testing
@@ -393,7 +450,16 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
       this._clearSubscriptions();
       this._requestId = null;
       this.setReadyState(this.DONE);
-
+      if (XMLHttpRequest._profiling && this._startTime != null) {
+        const start = this._startTime;
+        console.timeStamp(
+          this._getMeasureURL(),
+          start,
+          undefined,
+          PERFORMANCE_TRACK_NAME,
+          PERFORMANCE_TRACK_GROUP,
+        );
+      }
       if (error) {
         XMLHttpRequest._interceptor &&
           XMLHttpRequest._interceptor.loadingFailed(requestId, error);
@@ -421,12 +487,49 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
       // according to the spec, return null if no response has been received
       return null;
     }
-    const headers = this.responseHeaders || {};
-    return Object.keys(headers)
-      .map(headerName => {
-        return headerName + ': ' + headers[headerName];
-      })
-      .join('\r\n');
+
+    // Assign to non-nullable local variable.
+    const responseHeaders = this.responseHeaders;
+
+    const unsortedHeaders: Map<
+      string,
+      {lowerHeaderName: string, upperHeaderName: string, headerValue: string},
+    > = new Map();
+    for (const rawHeaderName of Object.keys(responseHeaders)) {
+      const headerValue = responseHeaders[rawHeaderName];
+      const lowerHeaderName = rawHeaderName.toLowerCase();
+      const header = unsortedHeaders.get(lowerHeaderName);
+      if (header) {
+        header.headerValue += ', ' + headerValue;
+        unsortedHeaders.set(lowerHeaderName, header);
+      } else {
+        unsortedHeaders.set(lowerHeaderName, {
+          lowerHeaderName,
+          upperHeaderName: rawHeaderName.toUpperCase(),
+          headerValue,
+        });
+      }
+    }
+
+    // Sort in ascending order, with a being less than b if a's name is legacy-uppercased-byte less than b's name.
+    const sortedHeaders = [...unsortedHeaders.values()].sort((a, b) => {
+      if (a.upperHeaderName < b.upperHeaderName) {
+        return -1;
+      }
+      if (a.upperHeaderName > b.upperHeaderName) {
+        return 1;
+      }
+      return 0;
+    });
+
+    // Combine into single text response.
+    return (
+      sortedHeaders
+        .map(header => {
+          return header.lowerHeaderName + ': ' + header.headerValue;
+        })
+        .join('\r\n') + '\r\n'
+    );
   }
 
   getResponseHeader(header: string): ?string {
@@ -444,11 +547,19 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   /**
    * Custom extension for tracking origins of request.
    */
-  setTrackingName(trackingName: string): XMLHttpRequest {
+  setTrackingName(trackingName: ?string): XMLHttpRequest {
     this._trackingName = trackingName;
     return this;
   }
 
+  /**
+   * Custom extension for setting a custom performance logger
+   */
+  setPerformanceLogger(performanceLogger: IPerformanceLogger): XMLHttpRequest {
+    this._performanceLogger = performanceLogger;
+    return this;
+  }
+
   open(method: string, url: string, async: ?boolean): void {
     /* Other optional arguments are not supported yet */
     if (this.readyState !== this.UNSENT) {
@@ -518,10 +629,10 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
     }
 
     const doSend = () => {
-      const friendlyName =
-        this._trackingName !== 'unknown' ? this._trackingName : this._url;
+      const friendlyName = this._trackingName ?? this._url;
       this._perfKey = 'network_XMLHttpRequest_' + String(friendlyName);
-      GlobalPerformanceLogger.startTimespan(this._perfKey);
+      this._performanceLogger.startTimespan(this._perfKey);
+      this._startTime = performance.now();
       invariant(
         this._method,
         'XMLHttpRequest method needs to be defined (%s).',
@@ -534,7 +645,7 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
       );
       RCTNetworking.sendRequest(
         this._method,
-        this._trackingName,
+        this._trackingName ?? undefined,
         this._url,
         this._headers,
         data,
@@ -543,10 +654,13 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
         nativeResponseType,
         incrementalEvents,
         this.timeout,
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
         this.__didCreateRequest.bind(this),
         this.withCredentials,
       );
     };
+    /* $FlowFixMe[constant-condition] Error discovered during Constant
+     * Condition roll out. See https://fburl.com/workplace/1v97vimq. */
     if (DEBUG_NETWORK_SEND_DELAY) {
       setTimeout(doSend, DEBUG_NETWORK_SEND_DELAY);
     } else {
@@ -578,36 +692,35 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
   setResponseHeaders(responseHeaders: ?Object): void {
     this.responseHeaders = responseHeaders || null;
     const headers = responseHeaders || {};
-    this._lowerCaseResponseHeaders = Object.keys(headers).reduce(
-      (lcaseHeaders, headerName) => {
-        lcaseHeaders[headerName.toLowerCase()] = headers[headerName];
-        return lcaseHeaders;
-      },
-      {},
-    );
+    this._lowerCaseResponseHeaders = Object.keys(headers).reduce<{
+      [string]: any,
+    }>((lcaseHeaders, headerName) => {
+      // $FlowFixMe[invalid-computed-prop]
+      lcaseHeaders[headerName.toLowerCase()] = headers[headerName];
+      return lcaseHeaders;
+    }, {});
   }
 
   setReadyState(newState: number): void {
     this.readyState = newState;
-    this.dispatchEvent({type: 'readystatechange'});
+    dispatchTrustedEvent(this, new Event('readystatechange'));
     if (newState === this.DONE) {
       if (this._aborted) {
-        this.dispatchEvent({type: 'abort'});
+        dispatchTrustedEvent(this, new Event('abort'));
       } else if (this._hasError) {
         if (this._timedOut) {
-          this.dispatchEvent({type: 'timeout'});
+          dispatchTrustedEvent(this, new Event('timeout'));
         } else {
-          this.dispatchEvent({type: 'error'});
+          dispatchTrustedEvent(this, new Event('error'));
         }
       } else {
-        this.dispatchEvent({type: 'load'});
+        dispatchTrustedEvent(this, new Event('load'));
       }
-      this.dispatchEvent({type: 'loadend'});
+      dispatchTrustedEvent(this, new Event('loadend'));
     }
   }
 
-  /* global EventListener */
-  addEventListener(type: string, listener: EventListener): void {
+  addEventListener(type: string, listener: EventListener | null): void {
     // If we dont' have a 'readystatechange' event handler, we don't
     // have to send repeated LOADING events with incremental updates
     // to responseText, which will avoid a bunch of native -> JS
@@ -617,6 +730,80 @@ class XMLHttpRequest extends (EventTarget(...XHR_EVENTS): any) {
     }
     super.addEventListener(type, listener);
   }
+
+  _getMeasureURL(): string {
+    return (
+      this._trackingName ?? this._url ?? LABEL_FOR_MISSING_URL_FOR_PROFILING
+    );
+  }
+
+  /*
+   * `on<event>` event handling (without JS prototype magic).
+   */
+
+  get onabort(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'abort');
+  }
+
+  set onabort(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'abort', listener);
+  }
+
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+
+  get onload(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'load');
+  }
+
+  set onload(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'load', listener);
+  }
+
+  get onloadstart(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadstart');
+  }
+
+  set onloadstart(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadstart', listener);
+  }
+
+  get onprogress(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'progress');
+  }
+
+  set onprogress(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'progress', listener);
+  }
+
+  get ontimeout(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'timeout');
+  }
+
+  set ontimeout(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'timeout', listener);
+  }
+
+  get onloadend(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadend');
+  }
+
+  set onloadend(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadend', listener);
+  }
+
+  get onreadystatechange(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'readystatechange');
+  }
+
+  set onreadystatechange(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'readystatechange', listener);
+  }
 }
 
-module.exports = XMLHttpRequest;
+export default XMLHttpRequest;

package/Libraries/Network/convertRequestBody.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -10,10 +10,12 @@
 
 'use strict';
 
-const binaryToBase64 = require('../Utilities/binaryToBase64');
+import typeof BlobT from '../Blob/Blob';
+import typeof FormDataT from './FormData';
 
-const Blob = require('../Blob/Blob');
-const FormData = require('./FormData');
+const Blob: BlobT = require('../Blob/Blob').default;
+const binaryToBase64 = require('../Utilities/binaryToBase64').default;
+const FormData: FormDataT = require('./FormData').default;
 
 export type RequestBody =
   | string
@@ -34,10 +36,11 @@ function convertRequestBody(body: RequestBody): Object {
     return {formData: body.getParts()};
   }
   if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
-    // $FlowFixMe: no way to assert that 'body' is indeed an ArrayBufferView
+    /* $FlowFixMe[incompatible-call] : no way to assert that 'body' is indeed
+     * an ArrayBufferView */
     return {base64: binaryToBase64(body)};
   }
   return body;
 }
 
-module.exports = convertRequestBody;
+export default convertRequestBody;

package/Libraries/Network/fetch.js

@@ -1,18 +1,20 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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
  */
 
-/* globals Headers, Request, Response */
-
 'use strict';
 
 // side-effectful require() to put fetch,
 // Headers, Request, Response in global scope
 require('whatwg-fetch');
 
-module.exports = {fetch, Headers, Request, Response};
+export const fetch = global.fetch;
+export const Headers = global.Headers;
+export const Request = global.Request;
+export const Response = global.Response;

package/Libraries/Performance/Systrace.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+
+type EventName = string | (() => string);
+type EventArgs = {[key: string]: string} | void | null;
+
+/**
+ * Indicates if the application is currently being traced.
+ *
+ * Calling methods on this module when the application isn't being traced is
+ * cheap, but this method can be used to avoid computing expensive values for
+ * those functions.
+ *
+ * @example
+ * if (Systrace.isEnabled()) {
+ *   const expensiveArgs = computeExpensiveArgs();
+ *   Systrace.beginEvent('myEvent', expensiveArgs);
+ * }
+ */
+export function isEnabled(): boolean;
+
+/**
+ * @deprecated This function is now a no-op but it's left for backwards
+ * compatibility. `isEnabled` will now synchronously check if we're actively
+ * profiling or not. This is necessary because we don't have callbacks to know
+ * when profiling has started/stopped on Android APIs.
+ */
+export function setEnabled(_doEnable: boolean): void;
+
+/**
+ * Marks the start of a synchronous event that should end in the same stack
+ * frame. The end of this event should be marked using the `endEvent` function.
+ */
+export function beginEvent(eventName: EventName, args?: EventArgs): void;
+
+/**
+ * Marks the end of a synchronous event started in the same stack frame.
+ */
+export function endEvent(args?: EventArgs): void;
+
+/**
+ * Marks the start of a potentially asynchronous event. The end of this event
+ * should be marked calling the `endAsyncEvent` function with the cookie
+ * returned by this function.
+ */
+export function beginAsyncEvent(eventName: EventName, args?: EventArgs): number;
+
+/**
+ * Registers a new value for a counter event.
+ */
+export function endAsyncEvent(
+  eventName: EventName,
+  cookie: number,
+  args?: EventArgs,
+): void;
+
+/**
+ * counterEvent registers the value to the eventName on the systrace timeline
+ **/
+export function counterEvent(eventName: EventName, value: number): void;