Moved the client-side specialization logic to a class and registry based

system much like the backend to make specialization logic more
encapsulated and easier to produce

Author: Sturdyfool11

src/configuration.rs

@@ -17,7 +17,7 @@ use serde_json::Value;
 /// * `registry` - The specialization registry to check allowed types.
 pub fn validate_specializations_in_config(config_json: &Value, registry: &SpecializationRegistry) {
     let allowed: Vec<String> = registry
-        .allowed_names()
+        .existing_names()
         .into_iter()
         .map(|name| format!("\"{}\"", name))
         .collect();

src/html_src/index.js

@@ -209,7 +209,7 @@ function addServerDropdown(serverName, inactive) {
   if (inactive == true) {
     dropdown.toggleClass("inactiveServer");
   }
-  updateServerInfoMCSpecialization();
+  updateServerInfoSpecializations();
 }
 
 function addDropdownNoDupe(name, inactive) {
@@ -233,35 +233,59 @@ function checkAllServers() {
   var servers = $(".CentralMenuDropdown").toArray();
   //finish this, make sure serverInfo
 }
-function updateServerInfoMCSpecialization() {
+/**
+ * Specialization base class.
+ * Extend this for each server specialization.
+ */
+class ServerSpecialization {
+  updateUI(dropdownElement, server) {
+    // Default: do nothing
+  }
+}
+
+/**
+ * Minecraft specialization class.
+ */
+class MinecraftSpecialization extends ServerSpecialization {
+  updateUI(dropdownElement, server) {
+    const serverNameElem = dropdownElement.querySelector(".serverName");
+    if (serverNameElem) {
+      if (server.active) {
+        let playerCount = server.specialized_info?.player_count ?? 0;
+        let maxPlayers = server.specialized_info?.max_players ?? 0;
+        let isReady = server.specialized_info?.ready ?? false;
+        let statusText = isReady ? "ready to join" : "starting";
+        serverNameElem.textContent = `${server.name} (${playerCount} / ${maxPlayers}) Status: ${statusText}`;
+      } else {
+        serverNameElem.textContent = `${server.name} (inactive)`;
+      }
+    }
+  }
+}
+
+/**
+ * Specialization registry.
+ * Maps config string to specialization class instance.
+ */
+const specializationRegistry = {
+  Minecraft: new MinecraftSpecialization(),
+  // Add more: Rust: new RustSpecialization(), etc.
+};
+
+/**
+ * Generic update function for all specializations.
+ * Calls the appropriate specialization's updateUI for each server.
+ */
+function updateServerInfoSpecializations() {
   try {
     const serverInfo = window.serverInfoObj;
+    if (!serverInfo || !serverInfo.servers) return;
     serverInfo.servers.forEach((server) => {
-      if (server.specialization === "Minecraft") {
-        // Check if the specialization is Minecraft
-        const serverElement = $(`.${server.name}dropdown`).find(
-          ".serverName",
-        )[0];
-        if (serverElement) {
-          if (server.active) {
-            // Expect specialized_info to be an object with player_count, max_players, ready
-            let playerCount = 0;
-            let maxPlayers = 0;
-            let isReady = false;
-            if (
-              server.specialized_info &&
-              typeof server.specialized_info === "object"
-            ) {
-              playerCount = server.specialized_info.player_count ?? 0;
-              maxPlayers = server.specialized_info.max_players ?? 0;
-              isReady = server.specialized_info.ready ?? false;
-            }
-            let statusText = isReady ? "ready to join" : "starting";
-            serverElement.textContent = `${server.name} (${playerCount} / ${maxPlayers}) Status: ${statusText}`;
-          } else {
-            serverElement.textContent = `${server.name} (inactive)`;
-          }
-        }
+      const dropdownElement = document.querySelector(`.${server.name}dropdown`);
+      if (!dropdownElement) return;
+      const specialization = specializationRegistry[server.specialization];
+      if (specialization) {
+        specialization.updateUI(dropdownElement, server);
       }
     });
   } catch (e) {}
@@ -296,7 +320,7 @@ $(document).ready(function () {
     hotReloadWhenReady();
   };
   // Set interval to update server info every quarter second
-  setInterval(updateServerInfoMCSpecialization, 250);
+  setInterval(updateServerInfoSpecializations, 250);
 
   socket.onclose = function () {
     hotReloadWhenReady();

src/specializations/minecraft.rs

@@ -216,7 +216,6 @@ pub fn factory() -> Box<dyn ServerSpecialization> {
     Box::new(MinecraftSpecialization::default())
 }
 
-/// Colorizes a single Minecraft log line using bracket counting.
 /// Colorizes a single Minecraft log line using bracket counting and HTML spans.
 ///
 /// Applies faded color to the timestamp, semantic color to the log level,
@@ -272,7 +271,7 @@ fn colorize_minecraft_log_line(line: &str) -> String {
 
     // Theme variable mapping
     fn type_to_var(typ: &str) -> &'static str {
-        if typ.contains("ERROR") {
+        if typ.contains("ERROR") || typ.contains("FATAL") {
             "var(--danger)"
         } else if typ.contains("WARN") {
             "var(--warning)"

src/specializations/mod.rs

@@ -50,19 +50,17 @@ pub trait ServerSpecialization: Send + Sync {
     fn get_status(&self) -> serde_json::Value;
 }
 
-/// Factory type for creating new specialization instances.
 /// Factory type for creating new specialization instances.
 pub type SpecializationFactory = fn() -> Box<dyn ServerSpecialization>;
 
-/// Thread-safe registry for all available specializations.
 /// Thread-safe registry for all available specializations.
 pub struct SpecializationRegistry {
     map: DashMap<String, SpecializationFactory>,
 }
 
 impl SpecializationRegistry {
     /// Returns a Vec of allowed specialization names.
-    pub fn allowed_names(&self) -> Vec<String> {
+    pub fn existing_names(&self) -> Vec<String> {
         self.map
             .iter()
             .map(|entry| entry.key().to_string())
@@ -73,9 +71,6 @@ impl SpecializationRegistry {
     pub fn contains_key(&self, key: &str) -> bool {
         self.map.contains_key(key)
     }
-}
-
-impl SpecializationRegistry {
     /// Create a new, empty registry.
     pub fn new() -> Self {
         Self {
@@ -104,7 +99,6 @@ impl SpecializationRegistry {
     }
 }
 
-/// Helper to initialize the registry with built-in specializations.
 /// Helper to initialize the registry with built-in specializations.
 ///
 /// Registers "Minecraft" and "Terraria" specializations by default.