fix(linting): fixup some linting issues

- This is a quick fix to get ci running again
- As a result I still need better defined messages

src/WebTty.UI/services/serializers.ts

@@ -2,8 +2,13 @@ import { encode, decode } from "@msgpack/msgpack"
 import { OpenNewTabReply, StdOutMessage, OpenNewTabRequest, StdInputRequest, ResizeTabMessage } from "@webtty/messages"
 import { BinaryMessageFormat } from "utils/BinaryFormat"
 
-type Commands = any
-type Events = any
+type Messages =
+    | OpenNewTabReply
+    | StdOutMessage
+    | OpenNewTabRequest
+    | OpenNewTabReply
+    | ResizeTabMessage
+    | StdInputRequest
 
 const getName = (message: unknown): string => {
     if (message instanceof OpenNewTabRequest) return "OpenNewTabRequest"
@@ -13,14 +18,14 @@ const getName = (message: unknown): string => {
     return ""
 }
 
-const serializeCommands = (message: OpenNewTabRequest | ResizeTabMessage | StdInputRequest): ArrayBuffer => {
+const serializeCommands = (message: Messages): ArrayBuffer => {
     const bytes = encode(message.toJSON())
     const payload = encode([getName(message), bytes]).slice()
     const data = BinaryMessageFormat.write(payload)
     return data
 }
 
-async function* deserializeMessages(dataStream: AsyncIterable<MessageEvent>): AsyncIterable<any> {
+async function* deserializeMessages(dataStream: AsyncIterable<MessageEvent>): AsyncIterable<Messages> {
     for await (const event of dataStream) {
         if (!event) continue
 
@@ -38,7 +43,7 @@ async function* deserializeMessages(dataStream: AsyncIterable<MessageEvent>): As
 
                 case "StdOutMessage": {
                     const stdOut = StdOutMessage.fromJS(payload)
-                    stdOut.data = Array.from((payload as any)["Data"])
+                    stdOut.data = Array.from((payload as { Data: number[] })["Data"])
                     yield stdOut
                     break
                 }
@@ -50,5 +55,5 @@ async function* deserializeMessages(dataStream: AsyncIterable<MessageEvent>): As
     }
 }
 
-export { Commands, Events }
+export { Messages }
 export { serializeCommands, deserializeMessages }

src/WebTty.UI/services/terminal.ts

@@ -2,13 +2,13 @@ import { produce } from "immer"
 import { TerminalState, TerminalActions, TERMINAL_NEW_TAB_CREATED } from "./types"
 import AsyncQueue from "../utils/AsyncQueue"
 import { OpenNewTabRequest, OpenNewTabReply, StdOutMessage, ResizeTabMessage, StdInputRequest } from "@webtty/messages"
-import { Commands, Events } from "./serializers"
+import { Messages } from "./serializers"
 
 const initialState = {
     tabId: undefined,
 }
 
-type DispatchCommand = (command: Commands) => void
+type DispatchCommand = (command: Messages) => void
 type Dispatch<A, R = void> = (action: A) => R
 
 const terminalReducer = (state: TerminalState = initialState, action: TerminalActions): TerminalState =>
@@ -34,7 +34,7 @@ const writeStdIn = (dispatch: DispatchCommand) => (id: string, payload: string):
     dispatch(input)
 }
 
-async function* stdoutMessageStream(id: string, messageStream: AsyncQueue<Events>): AsyncIterableIterator<string> {
+async function* stdoutMessageStream(id: string, messageStream: AsyncQueue<Messages>): AsyncIterableIterator<string> {
     const decoder = new TextDecoder()
     for await (const message of messageStream) {
         if (message instanceof StdOutMessage) {
@@ -43,7 +43,7 @@ async function* stdoutMessageStream(id: string, messageStream: AsyncQueue<Events
     }
 }
 
-const newTabMessageStream = (messageStream: AsyncQueue<Events>) =>
+const newTabMessageStream = (messageStream: AsyncQueue<Messages>) =>
     async function(dispatch: Dispatch<TerminalActions>): Promise<void> {
         for await (const message of messageStream) {
             if (message instanceof OpenNewTabReply) {

src/WebTty.UI/services/useWebTty.ts

@@ -5,7 +5,7 @@ import { terminalReducer, stdoutMessageStream } from "./terminal"
 import AsyncQueue from "../utils/AsyncQueue"
 import { openNewTab, resizeTerminal, writeStdIn, newTabMessageStream } from "./terminal"
 import { TerminalState } from "./types"
-import { serializeCommands, Commands, Events, deserializeMessages } from "./serializers"
+import { serializeCommands, Messages, deserializeMessages } from "./serializers"
 
 type WebTtyConnection = {
     state: TerminalState
@@ -22,7 +22,7 @@ const useWebTty = (endpoint: string): WebTtyConnection => {
     const [state, dispatch] = useReducer(terminalReducer, { tabId: undefined })
 
     const actions = useMemo(() => {
-        const dispatchCommand = (command: Commands): void => {
+        const dispatchCommand = (command: Messages): void => {
             const serialized = serializeCommands(command)
             sendMessage(serialized)
         }
@@ -34,7 +34,7 @@ const useWebTty = (endpoint: string): WebTtyConnection => {
         }
     }, [sendMessage])
 
-    const messageStream = useMemo((): AsyncQueue<Events> => {
+    const messageStream = useMemo((): AsyncQueue<Messages> => {
         const eventStream = deserializeMessages(dataStream)
         const queue = AsyncQueue.from(eventStream)
         return queue

src/WebTty.UI/utils/AsyncQueue.ts

@@ -18,7 +18,7 @@ class AsyncQueue<T> {
             listeners.push(queue)
             ;(async function(): Promise<void> {
                 try {
-                    for await (let message of iterator) {
+                    for await (const message of iterator) {
                         listeners.forEach(l => {
                             if (l.isDisposed) return
 

src/WebTty.UI/utils/fromEmitter.ts

@@ -9,9 +9,9 @@ interface EventEmitter {
 
 function fromEmitter<T>(
     eventEmitter: EventEmitter,
-    data: string = "message",
-    error: string = "error",
-    close: string = "close",
+    data = "message",
+    error = "error",
+    close = "close",
 ): AsyncIterable<T> {
     const queue = new AsyncQueue<T>()