prettier: Re-format .ts files

ext/src/background/receiverSelector/ReceiverSelector.ts

@@ -8,25 +8,22 @@ import { TypedEventTarget } from "../../lib/TypedEventTarget";
 import { getWindowCenteredProps, WindowCenteredProps } from "../../lib/utils";
 import { ReceiverDevice } from "../../types";
 
-import { ReceiverSelectionCast
-       , ReceiverSelectionStop
-       , ReceiverSelectorMediaType } from "./index";
-
-
+import {
+    ReceiverSelectionCast,
+    ReceiverSelectionStop,
+    ReceiverSelectorMediaType
+} from "./index";
 
 const POPUP_URL = browser.runtime.getURL("ui/popup/index.html");
 
-
 interface ReceiverSelectorEvents {
-    "selected": ReceiverSelectionCast;
-    "error": string;
-    "cancelled": void;
-    "stop": ReceiverSelectionStop;
+    selected: ReceiverSelectionCast;
+    error: string;
+    cancelled: void;
+    stop: ReceiverSelectionStop;
 }
 
-export default class ReceiverSelector
-        extends TypedEventTarget<ReceiverSelectorEvents> {
-
+export default class ReceiverSelector extends TypedEventTarget<ReceiverSelectorEvents> {
     private windowId?: number;
 
     private messagePort?: Port;
@@ -65,11 +62,11 @@ export default class ReceiverSelector
     }
 
     public async open(
-            receivers: ReceiverDevice[]
-          , defaultMediaType: ReceiverSelectorMediaType
-          , availableMediaTypes: ReceiverSelectorMediaType
-          , appId?: string): Promise<void> {
-
+        receivers: ReceiverDevice[],
+        defaultMediaType: ReceiverSelectorMediaType,
+        availableMediaTypes: ReceiverSelectorMediaType,
+        appId?: string
+    ): Promise<void> {
         this.appId = appId;
 
         // If popup already exists, close it
@@ -81,27 +78,28 @@ export default class ReceiverSelector
         this.defaultMediaType = defaultMediaType;
         this.availableMediaTypes = availableMediaTypes;
 
-
         let centeredProps: WindowCenteredProps = {
-            left: 100
-          , top: 100
-          , width: 350
-          , height: 200
+            left: 100,
+            top: 100,
+            width: 350,
+            height: 200
         };
 
         try {
             // Calculate centered size/position based on current window
             centeredProps = getWindowCenteredProps(
-                    await browser.windows.getCurrent()
-                  , centeredProps.width, centeredProps.height);
+                await browser.windows.getCurrent(),
+                centeredProps.width,
+                centeredProps.height
+            );
         } catch {
             // Shouldn't ever hit this, but defaults are provided in case
         }
 
         const popup = await browser.windows.create({
-            url: POPUP_URL
-          , type: "popup"
-          , ...centeredProps
+            url: POPUP_URL,
+            type: "popup",
+            ...centeredProps
         });
 
         if (popup?.id === undefined) {
@@ -116,22 +114,23 @@ export default class ReceiverSelector
             ...centeredProps
         });
 
-
         const closeIfFocusLost = await options.get(
-                "receiverSelectorCloseIfFocusLost");
+            "receiverSelectorCloseIfFocusLost"
+        );
 
         if (closeIfFocusLost) {
             // Add focus listener
             browser.windows.onFocusChanged.addListener(
-                    this.onWindowsFocusChanged);
+                this.onWindowsFocusChanged
+            );
         }
     }
 
     public update(receivers: ReceiverDevice[]) {
         this.receivers = receivers;
         this.messagePort?.postMessage({
-            subject: "popup:update"
-          , data: {
+            subject: "popup:update",
+            data: {
                 receivers: this.receivers
             }
         });
@@ -167,23 +166,25 @@ export default class ReceiverSelector
             this.messagePortDisconnected = true;
         });
 
-        if (!this.receivers
-         || !this.defaultMediaType
-         || !this.availableMediaTypes) {
+        if (
+            !this.receivers ||
+            !this.defaultMediaType ||
+            !this.availableMediaTypes
+        ) {
             throw logger.error("Popup receiver data not found.");
         }
 
         this.messagePort.postMessage({
-            subject: "popup:init"
-          , data: { appId: this.appId }
+            subject: "popup:init",
+            data: { appId: this.appId }
         });
 
         this.messagePort.postMessage({
-            subject: "popup:update"
-          , data: {
-                receivers: this.receivers
-              , defaultMediaType: this.defaultMediaType
-              , availableMediaTypes: this.availableMediaTypes
+            subject: "popup:update",
+            data: {
+                receivers: this.receivers,
+                defaultMediaType: this.defaultMediaType,
+                availableMediaTypes: this.availableMediaTypes
             }
         });
 
@@ -197,17 +198,21 @@ export default class ReceiverSelector
         switch (message.subject) {
             case "receiverSelector:selected": {
                 this.wasReceiverSelected = true;
-                this.dispatchEvent(new CustomEvent("selected", {
-                    detail: message.data
-                }));
+                this.dispatchEvent(
+                    new CustomEvent("selected", {
+                        detail: message.data
+                    })
+                );
 
                 break;
             }
 
             case "receiverSelector:stop": {
-                this.dispatchEvent(new CustomEvent("stop", {
-                    detail: message.data
-                }));
+                this.dispatchEvent(
+                    new CustomEvent("stop", {
+                        detail: message.data
+                    })
+                );
 
                 break;
             }
@@ -226,7 +231,8 @@ export default class ReceiverSelector
 
         browser.windows.onRemoved.removeListener(this.onWindowsRemoved);
         browser.windows.onFocusChanged.removeListener(
-                this.onWindowsFocusChanged);
+            this.onWindowsFocusChanged
+        );
 
         if (!this.wasReceiverSelected) {
             this.dispatchEvent(new CustomEvent("cancelled"));
@@ -247,12 +253,14 @@ export default class ReceiverSelector
      * `WINDOW_ID_NONE` or if the popup window is re-focused.
      */
     private onWindowsFocusChanged(windowId: number) {
-        if (windowId !== browser.windows.WINDOW_ID_NONE
-                && windowId !== this.windowId) {
-
+        if (
+            windowId !== browser.windows.WINDOW_ID_NONE &&
+            windowId !== this.windowId
+        ) {
             // Only run once
             browser.windows.onFocusChanged.removeListener(
-                    this.onWindowsFocusChanged);
+                this.onWindowsFocusChanged
+            );
 
             if (this.windowId) {
                 browser.windows.remove(this.windowId);

ext/src/background/receiverSelector/ReceiverSelectorManager.ts

@@ -8,18 +8,18 @@ import receiverDevices from "../receiverDevices";
 
 import { getMediaTypesForPageUrl } from "../../lib/utils";
 
-import { ReceiverSelection
-       , ReceiverSelectionActionType
-       , ReceiverSelectorMediaType } from "./index";
+import {
+    ReceiverSelection,
+    ReceiverSelectionActionType,
+    ReceiverSelectorMediaType
+} from "./index";
 
 import ReceiverSelector from "./ReceiverSelector";
 
-
 async function createSelector() {
     return new ReceiverSelector();
 }
 
-
 let sharedSelector: ReceiverSelector;
 
 async function getSelector() {
@@ -34,7 +34,6 @@ async function getSelector() {
     return sharedSelector;
 }
 
-
 /**
  * Opens a receiver selector with the specified
  * default/available media types.
@@ -46,21 +45,18 @@ async function getSelector() {
  *   - Rejects if the selection fails.
  */
 async function getSelection(
-        contextTabId: number
-      , contextFrameId = 0
-      , withMediaSender = false)
-        : Promise<ReceiverSelection | null> {
-
+    contextTabId: number,
+    contextFrameId = 0,
+    withMediaSender = false
+): Promise<ReceiverSelection | null> {
     return new Promise(async (resolve, reject) => {
-        let currentShim = ShimManager.getShim(
-                contextTabId, contextFrameId);
+        let currentShim = ShimManager.getShim(contextTabId, contextFrameId);
 
         /**
          * If the current context is running the mirroring app, pretend
          * it doesn't exist because it shouldn't be launched like this.
          */
-        if (currentShim?.appId ===
-                await options.get("mirroringAppId")) {
+        if (currentShim?.appId === (await options.get("mirroringAppId"))) {
             currentShim = undefined;
         }
 
@@ -69,13 +65,15 @@ async function getSelection(
 
         try {
             const { url } = await browser.webNavigation.getFrame({
-                tabId: contextTabId
-              , frameId: contextFrameId
+                tabId: contextTabId,
+                frameId: contextFrameId
             });
 
             availableMediaTypes = getMediaTypesForPageUrl(url);
         } catch {
-            logger.error("Failed to locate frame, falling back to default available media types.");
+            logger.error(
+                "Failed to locate frame, falling back to default available media types."
+            );
             availableMediaTypes = ReceiverSelectorMediaType.File;
         }
 
@@ -90,8 +88,8 @@ async function getSelection(
         // Remove mirroring media types if mirroring is not enabled
         if (!opts.mirroringEnabled) {
             availableMediaTypes &= ~(
-                    ReceiverSelectorMediaType.Tab
-                  | ReceiverSelectorMediaType.Screen);
+                ReceiverSelectorMediaType.Tab | ReceiverSelectorMediaType.Screen
+            );
         }
 
         // Remove file media type if local media is not enabled
@@ -107,26 +105,28 @@ async function getSelection(
         // Get a new selector for each selection
         sharedSelector = await createSelector();
 
-
         function onReceiverChange() {
             sharedSelector.update(receiverDevices.getDevices());
         }
 
+        receiverDevices.addEventListener("receiverDeviceUp", onReceiverChange);
         receiverDevices.addEventListener(
-                "receiverDeviceUp", onReceiverChange);
+            "receiverDeviceDown",
+            onReceiverChange
+        );
         receiverDevices.addEventListener(
-                "receiverDeviceDown", onReceiverChange);
-        receiverDevices.addEventListener(
-                "receiverDeviceUpdated", onReceiverChange);
-
+            "receiverDeviceUpdated",
+            onReceiverChange
+        );
 
         let onSelected: any;
         let onCancelled: any;
         let onError: any;
         let onStop: any;
 
-        type EvParamsType =
-                Parameters<typeof sharedSelector.addEventListener>[0];
+        type EvParamsType = Parameters<
+            typeof sharedSelector.addEventListener
+        >[0];
 
         function storeListener<T>(type: EvParamsType, fn: T) {
             if (type === "selected") {
@@ -149,67 +149,78 @@ async function getSelection(
             sharedSelector.removeEventListener("stop", onStop);
 
             receiverDevices.removeEventListener(
-                    "receiverDeviceUp", onReceiverChange);
+                "receiverDeviceUp",
+                onReceiverChange
+            );
             receiverDevices.removeEventListener(
-                    "receiverDeviceDown", onReceiverChange);
+                "receiverDeviceDown",
+                onReceiverChange
+            );
             receiverDevices.removeEventListener(
-                    "receiverDeviceUpdated", onReceiverChange);
+                "receiverDeviceUpdated",
+                onReceiverChange
+            );
         }
 
-        sharedSelector.addEventListener("selected"
-              , storeListener("selected", ev => {
+        sharedSelector.addEventListener(
+            "selected",
+            storeListener("selected", ev => {
+                logger.info("Selected receiver", ev.detail);
+                resolve({
+                    actionType: ReceiverSelectionActionType.Cast,
+                    receiver: ev.detail.receiver,
+                    mediaType: ev.detail.mediaType,
+                    filePath: ev.detail.filePath
+                });
+                removeListeners();
+            })
+        );
 
-            logger.info("Selected receiver", ev.detail);
-            resolve({
-                actionType: ReceiverSelectionActionType.Cast
-              , receiver: ev.detail.receiver
-              , mediaType: ev.detail.mediaType
-              , filePath: ev.detail.filePath
-            });
-            removeListeners();
-        }));
+        sharedSelector.addEventListener(
+            "cancelled",
+            storeListener("cancelled", () => {
+                logger.info("Cancelled receiver selection");
+                resolve(null);
+                removeListeners();
+            })
+        );
 
-        sharedSelector.addEventListener("cancelled"
-              , storeListener("cancelled", () => {
+        sharedSelector.addEventListener(
+            "error",
+            storeListener("error", () => {
+                reject();
+                removeListeners();
+            })
+        );
 
-            logger.info("Cancelled receiver selection");
-            resolve(null);
-            removeListeners();
-        }));
+        sharedSelector.addEventListener(
+            "stop",
+            storeListener("stop", async ev => {
+                logger.info("Stopping receiver app...", ev.detail);
 
-        sharedSelector.addEventListener("error"
-              , storeListener("error", () => {
-            reject();
-            removeListeners();
-        }));
-
-        sharedSelector.addEventListener("stop"
-              , storeListener("stop", async ev => {
-
-            logger.info("Stopping receiver app...", ev.detail);
-
-            receiverDevices.stopReceiverApp(ev.detail.receiver.id);
-
-            resolve({
-                actionType: ReceiverSelectionActionType.Stop
-              , receiver: ev.detail.receiver
-            });
-            removeListeners();
-        }));
+                receiverDevices.stopReceiverApp(ev.detail.receiver.id);
 
+                resolve({
+                    actionType: ReceiverSelectionActionType.Stop,
+                    receiver: ev.detail.receiver
+                });
+                removeListeners();
+            })
+        );
 
         // Ensure status manager is initialized
         await receiverDevices.init();
 
         sharedSelector.open(
-                receiverDevices.getDevices()
-              , defaultMediaType
-              , availableMediaTypes
-              , currentShim?.appId);
+            receiverDevices.getDevices(),
+            defaultMediaType,
+            availableMediaTypes,
+            currentShim?.appId
+        );
     });
 }
 
 export default {
-    getSelection
-  , getSelector
+    getSelection,
+    getSelector
 };

ext/src/background/receiverSelector/index.ts

@@ -1,20 +1,20 @@
 "use strict";
 
 export enum ReceiverSelectorType {
-    Popup
-  , Native
+    Popup,
+    Native
 }
 
 export enum ReceiverSelectorMediaType {
-    App = 1
-  , Tab = 2
-  , Screen = 4
-  , File = 8
+    App = 1,
+    Tab = 2,
+    Screen = 4,
+    File = 8
 }
 
 export enum ReceiverSelectionActionType {
-    Cast = 1
-  , Stop = 2
+    Cast = 1,
+    Stop = 2
 }
 
 export interface ReceiverSelectionCast {