Split sort event

The sort event bundled networks and channels for no reason at all.
They share none of the actual logic, so combining them just makes
the typing poor but serves no benefit.

client/js/socket-events/sync_sort.ts

@@ -1,30 +1,16 @@
 import socket from "../socket";
 import {store} from "../store";
 
-socket.on("sync_sort", function (data) {
-	const order = data.order;
-
-	switch (data.type) {
-		case "networks":
-			store.commit(
-				"sortNetworks",
-				(a, b) => (order as string[]).indexOf(a.uuid) - (order as string[]).indexOf(b.uuid)
-			);
-
-			break;
-
-		case "channels": {
-			const network = store.getters.findNetwork(data.target);
-
-			if (!network) {
-				return;
-			}
+socket.on("sync_sort:networks", function (data) {
+	store.commit("sortNetworks", (a, b) => data.order.indexOf(a.uuid) - data.order.indexOf(b.uuid));
+});
 
-			network.channels.sort(
-				(a, b) => (order as number[]).indexOf(a.id) - (order as number[]).indexOf(b.id)
-			);
+socket.on("sync_sort:channels", function (data) {
+	const network = store.getters.findNetwork(data.network);
 
-			break;
-		}
+	if (!network) {
+		return;
 	}
+
+	network.channels.sort((a, b) => data.order.indexOf(a.id) - data.order.indexOf(b.id));
 });

server/client.ts

@@ -22,10 +22,8 @@ import ClientManager from "./clientManager";
 import {MessageStorage} from "./plugins/messageStorage/types";
 import {StorageCleaner} from "./storageCleaner";
 import {SearchQuery, SearchResponse} from "../shared/types/storage";
-import {ChanType} from "../shared/types/chan";
-
-type OrderItem = Chan["id"] | Network["uuid"];
-type Order = OrderItem[];
+import {SharedChan, ChanType} from "../shared/types/chan";
+import {SharedNetwork} from "../shared/types/network";
 
 const events = [
 	"away",
@@ -692,56 +690,39 @@ class Client {
 		this.emit("open", targetNetChan.chan.id);
 	}
 
-	sort(data: {order: Order; type: "networks" | "channels"; target: string}) {
-		const order = data.order;
+	sortChannels(netid: SharedNetwork["uuid"], order: SharedChan["id"][]) {
+		const network = _.find(this.networks, {uuid: netid});
 
-		if (!_.isArray(order)) {
+		if (!network) {
 			return;
 		}
 
-		switch (data.type) {
-			case "networks":
-				this.networks.sort((a, b) => order.indexOf(a.uuid) - order.indexOf(b.uuid));
-
-				// Sync order to connected clients
-				this.emit("sync_sort", {
-					order: this.networks.map((obj) => obj.uuid),
-					type: data.type,
-				});
-
-				break;
-
-			case "channels": {
-				const network = _.find(this.networks, {uuid: data.target});
-
-				if (!network) {
-					return;
-				}
-
-				network.channels.sort((a, b) => {
-					// Always sort lobby to the top regardless of what the client has sent
-					// Because there's a lot of code that presumes channels[0] is the lobby
-					if (a.type === ChanType.LOBBY) {
-						return -1;
-					} else if (b.type === ChanType.LOBBY) {
-						return 1;
-					}
-
-					return order.indexOf(a.id) - order.indexOf(b.id);
-				});
-
-				// Sync order to connected clients
-				this.emit("sync_sort", {
-					order: network.channels.map((obj) => obj.id),
-					type: data.type,
-					target: network.uuid,
-				});
-
-				break;
+		network.channels.sort((a, b) => {
+			// Always sort lobby to the top regardless of what the client has sent
+			// Because there's a lot of code that presumes channels[0] is the lobby
+			if (a.type === ChanType.LOBBY) {
+				return -1;
+			} else if (b.type === ChanType.LOBBY) {
+				return 1;
 			}
-		}
 
+			return order.indexOf(a.id) - order.indexOf(b.id);
+		});
+		this.save();
+		// Sync order to connected clients
+		this.emit("sync_sort:channels", {
+			target: network.uuid,
+			order: network.channels.map((obj) => obj.id),
+		});
+	}
+
+	sortNetworks(order: SharedNetwork["uuid"][]) {
+		this.networks.sort((a, b) => order.indexOf(a.uuid) - order.indexOf(b.uuid));
 		this.save();
+		// Sync order to connected clients
+		this.emit("sync_sort:networks", {
+			order: this.networks.map((obj) => obj.uuid),
+		});
 	}
 
 	names(data: {target: number}) {

server/server.ts

@@ -569,10 +569,28 @@ function initializeClient(
 		client.open(socket.id, data);
 	});
 
-	socket.on("sort", (data) => {
-		if (_.isPlainObject(data)) {
-			client.sort(data);
+	socket.on("sort:networks", (data) => {
+		if (!_.isPlainObject(data)) {
+			return;
+		}
+
+		if (!Array.isArray(data.order)) {
+			return;
+		}
+
+		client.sortNetworks(data.order);
+	});
+
+	socket.on("sort:channels", (data) => {
+		if (!_.isPlainObject(data)) {
+			return;
 		}
+
+		if (!Array.isArray(data.order) || typeof data.network !== "string") {
+			return;
+		}
+
+		client.sortChannels(data.network, data.order);
 	});
 
 	socket.on("names", (data) => {

shared/types/socket-events.d.ts

@@ -1,5 +1,5 @@
 import {SharedMention} from "./mention";
-import {ChanState, InitClientChan} from "./chan";
+import {ChanState, InitClientChan, SharedChan} from "./chan";
 import {SharedNetwork} from "./network";
 import {SharedMsg, ClientMessage, LinkPreview} from "./msg";
 import {SharedUser} from "./user";
@@ -67,10 +67,11 @@ interface ServerToClientEvents {
 
 	"sign-out": NoPayloadEventHandler;
 
-	sync_sort: EventHandler<
-		| {type: "networks"; order: string[]; target: string}
-		| {type: "channels"; order: number[]; target: string}
-	>;
+	"sync_sort:networks": EventHandler<{order: SharedNetwork["uuid"][]}>;
+	"sync_sort:channels": EventHandler<{
+		network: SharedNetwork["uuid"];
+		order: SharedChan["id"][];
+	}>;
 
 	topic: EventHandler<{chan: number; topic: string}>;
 
@@ -134,7 +135,11 @@ interface ClientToServerEvents {
 
 	"sessions:get": NoPayloadEventHandler;
 
-	sort: EventHandler<{type: string; order: any; target?: string}>;
+	"sort:networks": EventHandler<{order: SharedNetwork["uuid"][]}>;
+	"sort:channels": EventHandler<{
+		network: SharedNetwork["uuid"];
+		order: SharedChan["id"][];
+	}>;
 
 	"mentions:dismiss": (msgId: number) => void;
 	"mentions:dismiss_all": NoPayloadEventHandler;