feat(ts) migrate JitsiMeetJS to TS

JitsiMeetJS.js → JitsiMeetJS.ts

  * @returns {*} the attributes to attach to analytics events.
  */
 function getAnalyticsAttributesFromOptions(options) {
-    const attributes = {
-        'audio_requested':
-            options.devices.includes('audio'),
-        'video_requested':
-            options.devices.includes('video'),
-        'screen_sharing_requested':
-            options.devices.includes('desktop')
-    };
+    const attributes: any = {};
+
+    attributes['audio_requested'] = options.devices.includes('audio');
+    attributes['video_requested'] = options.devices.includes('video');
+    attributes['screen_sharing_requested'] = options.devices.includes('desktop');
 
     if (attributes.video_requested) {
         attributes.resolution = options.resolution;
     return attributes;
 }
 
+interface ICreateLocalTrackOptions {
+    cameraDeviceId?: string;
+    devices?: any[];
+    firePermissionPromptIsShownEvent?: boolean;
+    fireSlowPromiseEvent?: boolean;
+    micDeviceId?: string;
+    resolution?: string;
+}
+
+interface IJitsiMeetJSOptions {
+    enableAnalyticsLogging?: boolean;
+    enableUnifiedOnChrome?: boolean;
+    enableWindowOnErrorHandler?: boolean;
+    externalStorage?: Storage;
+    flags?: {
+        enableUnifiedOnChrome?: boolean;
+    }
+}
+
 /**
  * The public API of the Jitsi Meet library (a.k.a. {@code JitsiMeetJS}).
  */
         JitsiTrackError
     },
     logLevels: Logger.levels,
-    mediaDevices: JitsiMediaDevices,
-    analytics: Statistics.analytics,
-    init(options = {}) {
+    mediaDevices: JitsiMediaDevices as unknown,
+    analytics: Statistics.analytics as unknown,
+    init(options: IJitsiMeetJSOptions = {}) {
         Settings.init(options.externalStorage);
         Statistics.init(options);
         const flags = options.flags || {};
      * that returns an array of created JitsiTracks if resolved, or a
      * JitsiConferenceError if rejected.
      */
-    createLocalTracks(options = {}, oldfirePermissionPromptIsShownEvent) {
+    createLocalTracks(options: ICreateLocalTrackOptions = {}, oldfirePermissionPromptIsShownEvent) {
         let promiseFulfilled = false;
 
         const { firePermissionPromptIsShownEvent, fireSlowPromiseEvent, ...restOptions } = options;
         const firePermissionPrompt = firePermissionPromptIsShownEvent || oldfirePermissionPromptIsShownEvent;
 
         if (firePermissionPrompt && !RTC.arePermissionsGrantedForAvailableDevices()) {
-            JitsiMediaDevices.emitEvent(
-                JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                browser.getName());
+            // @ts-ignore
+            JitsiMediaDevices.emitEvent(JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN, browser.getName());
         } else if (fireSlowPromiseEvent) {
             window.setTimeout(() => {
                 if (!promiseFulfilled) {
         window.connectionTimes['obtainPermissions.start']
             = window.performance.now();
 
+        // @ts-ignore
         return RTC.obtainAudioAndVideoPermissions(restOptions)
             .then(tracks => {
                 promiseFulfilled = true;

globals.d.ts

+export {};
+
+declare global {
+    interface Window {
+        connectionTimes: any;
+    }
+}

modules/connectivity/NetworkInfo.js

 
     /**
      * Updates the network info state.
-     * @param {boolean} isOnline - {@code true} if internet is online or {@code false} otherwise.
      */
     updateNetworkInfo({ isOnline }) {
         logger.debug('updateNetworkInfo', { isOnline });