fix: prettier config

src/context/filter-context.ts

@@ -1,10 +1,8 @@
-import { createContext } from "react";
+import { createContext } from "react"
 
 export interface FilterContextType {
-  filter: boolean;
-  setFilter: (filter: boolean) => void;
+  filter: boolean
+  setFilter: (filter: boolean) => void
 }
 
-export const FilterContext = createContext<FilterContextType | undefined>(
-  undefined,
-);
+export const FilterContext = createContext<FilterContextType | undefined>(undefined)

src/context/network-filter-context.tsx

@@ -1,14 +1,11 @@
-"use client";
+"use client"
 
-import { ReactNode, useState } from "react";
-import { FilterContext } from "./filter-context";
+import { ReactNode, useState } from "react"
+
+import { FilterContext } from "./filter-context"
 
 export function FilterProvider({ children }: { children: ReactNode }) {
-  const [filter, setFilter] = useState<boolean>(false);
+  const [filter, setFilter] = useState<boolean>(false)
 
-  return (
-    <FilterContext.Provider value={{ filter, setFilter }}>
-      {children}
-    </FilterContext.Provider>
-  );
+  return <FilterContext.Provider value={{ filter, setFilter }}>{children}</FilterContext.Provider>
 }

src/context/status-context.ts

@@ -1,12 +1,10 @@
-import { createContext } from "react";
+import { createContext } from "react"
 
-export type Status = "all" | "online" | "offline";
+export type Status = "all" | "online" | "offline"
 
 export interface StatusContextType {
-  status: Status;
-  setStatus: (status: Status) => void;
+  status: Status
+  setStatus: (status: Status) => void
 }
 
-export const StatusContext = createContext<StatusContextType | undefined>(
-  undefined,
-);
+export const StatusContext = createContext<StatusContextType | undefined>(undefined)

src/context/status-provider.tsx

@@ -1,12 +1,9 @@
-import { ReactNode, useState } from "react";
-import { Status, StatusContext } from "./status-context";
+import { ReactNode, useState } from "react"
+
+import { Status, StatusContext } from "./status-context"
 
 export function StatusProvider({ children }: { children: ReactNode }) {
-  const [status, setStatus] = useState<Status>("all");
+  const [status, setStatus] = useState<Status>("all")
 
-  return (
-    <StatusContext.Provider value={{ status, setStatus }}>
-      {children}
-    </StatusContext.Provider>
-  );
+  return <StatusContext.Provider value={{ status, setStatus }}>{children}</StatusContext.Provider>
 }

src/context/tooltip-context.ts

@@ -1,20 +1,18 @@
-import { createContext } from "react";
+import { createContext } from "react"
 
 export interface TooltipData {
-  centroid: [number, number];
-  country: string;
-  count: number;
+  centroid: [number, number]
+  country: string
+  count: number
   servers: Array<{
-    name: string;
-    status: boolean;
-  }>;
+    name: string
+    status: boolean
+  }>
 }
 
 interface TooltipContextType {
-  tooltipData: TooltipData | null;
-  setTooltipData: (data: TooltipData | null) => void;
+  tooltipData: TooltipData | null
+  setTooltipData: (data: TooltipData | null) => void
 }
 
-export const TooltipContext = createContext<TooltipContextType | undefined>(
-  undefined,
-);
+export const TooltipContext = createContext<TooltipContextType | undefined>(undefined)

src/context/tooltip-provider.tsx

@@ -1,12 +1,13 @@
-import { ReactNode, useState } from "react";
-import { TooltipContext, TooltipData } from "./tooltip-context";
+import { ReactNode, useState } from "react"
+
+import { TooltipContext, TooltipData } from "./tooltip-context"
 
 export function TooltipProvider({ children }: { children: ReactNode }) {
-  const [tooltipData, setTooltipData] = useState<TooltipData | null>(null);
+  const [tooltipData, setTooltipData] = useState<TooltipData | null>(null)
 
   return (
     <TooltipContext.Provider value={{ tooltipData, setTooltipData }}>
       {children}
     </TooltipContext.Provider>
-  );
+  )
 }

src/context/websocket-context.ts

@@ -1,11 +1,11 @@
-import { createContext } from "react";
+import { createContext } from "react"
 
 export interface WebSocketContextType {
-  lastMessage: { data: string } | null;
-  connected: boolean;
+  lastMessage: { data: string } | null
+  connected: boolean
 }
 
 export const WebSocketContext = createContext<WebSocketContextType>({
   lastMessage: null,
   connected: false,
-});
+})

src/context/websocket-provider.tsx

@@ -1,81 +1,75 @@
-import React, { useEffect, useRef, useState } from "react";
-import { WebSocketContext, WebSocketContextType } from "./websocket-context";
+import React, { useEffect, useRef, useState } from "react"
+
+import { WebSocketContext, WebSocketContextType } from "./websocket-context"
 
 interface WebSocketProviderProps {
-  url: string;
-  children: React.ReactNode;
+  url: string
+  children: React.ReactNode
 }
 
-export const WebSocketProvider: React.FC<WebSocketProviderProps> = ({
-  url,
-  children,
-}) => {
-  const [lastMessage, setLastMessage] = useState<{ data: string } | null>(null);
-  const [connected, setConnected] = useState(false);
-  const ws = useRef<WebSocket | null>(null);
-  const reconnectTimeout = useRef<NodeJS.Timeout>(null);
-  const maxReconnectAttempts = 30;
-  const reconnectAttempts = useRef(0);
+export const WebSocketProvider: React.FC<WebSocketProviderProps> = ({ url, children }) => {
+  const [lastMessage, setLastMessage] = useState<{ data: string } | null>(null)
+  const [connected, setConnected] = useState(false)
+  const ws = useRef<WebSocket | null>(null)
+  const reconnectTimeout = useRef<NodeJS.Timeout>(null)
+  const maxReconnectAttempts = 30
+  const reconnectAttempts = useRef(0)
 
   const connect = () => {
     try {
-      const wsUrl = new URL(url, window.location.origin);
-      wsUrl.protocol = wsUrl.protocol.replace("http", "ws");
+      const wsUrl = new URL(url, window.location.origin)
+      wsUrl.protocol = wsUrl.protocol.replace("http", "ws")
 
-      ws.current = new WebSocket(wsUrl.toString());
+      ws.current = new WebSocket(wsUrl.toString())
 
       ws.current.onopen = () => {
-        console.log("WebSocket connected");
-        setConnected(true);
-        reconnectAttempts.current = 0;
-      };
+        console.log("WebSocket connected")
+        setConnected(true)
+        reconnectAttempts.current = 0
+      }
 
       ws.current.onclose = () => {
-        console.log("WebSocket disconnected");
-        setConnected(false);
+        console.log("WebSocket disconnected")
+        setConnected(false)
 
         // 重连逻辑
         if (reconnectAttempts.current < maxReconnectAttempts) {
           reconnectTimeout.current = setTimeout(() => {
-            reconnectAttempts.current++;
-            connect();
-          }, 3000);
+            reconnectAttempts.current++
+            connect()
+          }, 3000)
         }
-      };
+      }
 
       ws.current.onmessage = (event) => {
-        setLastMessage({ data: event.data });
-      };
+        setLastMessage({ data: event.data })
+      }
 
       ws.current.onerror = (error) => {
-        console.error("WebSocket error:", error);
-      };
+        console.error("WebSocket error:", error)
+      }
     } catch (error) {
-      console.error("WebSocket connection error:", error);
+      console.error("WebSocket connection error:", error)
     }
-  };
+  }
 
   useEffect(() => {
-    connect();
+    connect()
 
     return () => {
       if (ws.current) {
-        ws.current.close();
+        ws.current.close()
       }
       if (reconnectTimeout.current) {
-        clearTimeout(reconnectTimeout.current);
+        clearTimeout(reconnectTimeout.current)
       }
-    };
-  }, [url]);
+    }
+  }, [url])
 
   const contextValue: WebSocketContextType = {
     lastMessage,
     connected,
-  };
+  }
 
-  return (
-    <WebSocketContext.Provider value={contextValue}>
-      {children}
-    </WebSocketContext.Provider>
-  );
-};
+  return <WebSocketContext.Provider value={contextValue}>{children}</WebSocketContext.Provider>
+}