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/components/NetworkList.vue

@@ -309,8 +309,7 @@ export default defineComponent({
 
 			moveItemInArray(store.state.networks, oldIndex, newIndex);
 
-			socket.emit("sort", {
+			socket.emit("sort:networks", {
-				type: "networks",
 				order: store.state.networks.map((n) => n.uuid),
 			});
 		};
@@ -341,9 +340,8 @@ export default defineComponent({
 
 			moveItemInArray(netChan.network.channels, oldIndex, newIndex);
 
-			socket.emit("sort", {
+			socket.emit("sort:channel", {
-				type: "channels",
+				network: netChan.network.uuid,
-				target: netChan.network.uuid,
 				order: netChan.network.channels.map((c) => c.id),
 			});
 		};

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) {
+socket.on("sync_sort:networks", function (data) {
-	const order = data.order;
+	store.commit("sortNetworks", (a, b) => data.order.indexOf(a.uuid) - data.order.indexOf(b.uuid));
-
+});
-	switch (data.type) {
+
-		case "networks":
+socket.on("sync_sort:channels", function (data) {
-			store.commit(
+	const network = store.getters.findNetwork(data.network);
-				"sortNetworks",
+
-				(a, b) => (order as string[]).indexOf(a.uuid) - (order as string[]).indexOf(b.uuid)
+	if (!network) {
-			);
+		return;
-
+	}
-			break;
+
-
+	network.channels.sort((a, b) => data.order.indexOf(a.id) - data.order.indexOf(b.id));
-		case "channels": {
-			const network = store.getters.findNetwork(data.target);
-
-			if (!network) {
-				return;
-			}
-
-			network.channels.sort(
-				(a, b) => (order as number[]).indexOf(a.id) - (order as number[]).indexOf(b.id)
-			);
-
-			break;
-		}
-	}
 });

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";
+import {SharedChan, ChanType} from "../shared/types/chan";
-
+import {SharedNetwork} from "../shared/types/network";
-type OrderItem = Chan["id"] | Network["uuid"];
-type Order = OrderItem[];
 
 const events = [
 	"away",
@@ -692,56 +690,39 @@ class Client {
 		this.emit("open", targetNetChan.chan.id);
 	}
 
-	sort(data: {order: Order; type: "networks" | "channels"; target: string}) {
+	sortChannels(netid: SharedNetwork["uuid"], order: SharedChan["id"][]) {
-		const order = data.order;
+		const network = _.find(this.networks, {uuid: netid});
 
-		if (!_.isArray(order)) {
+		if (!network) {
 			return;
 		}
 
-		switch (data.type) {
+		network.channels.sort((a, b) => {
-			case "networks":
+			// Always sort lobby to the top regardless of what the client has sent
-				this.networks.sort((a, b) => order.indexOf(a.uuid) - order.indexOf(b.uuid));
+			// Because there's a lot of code that presumes channels[0] is the lobby
-
+			if (a.type === ChanType.LOBBY) {
-				// Sync order to connected clients
+				return -1;
-				this.emit("sync_sort", {
+			} else if (b.type === ChanType.LOBBY) {
-					order: this.networks.map((obj) => obj.uuid),
+				return 1;
-					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;
 			}
-		}
 
+			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) => {
+	socket.on("sort:networks", (data) => {
-		if (_.isPlainObject(data)) {
+		if (!_.isPlainObject(data)) {
-			client.sort(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<
+	"sync_sort:networks": EventHandler<{order: SharedNetwork["uuid"][]}>;
-		| {type: "networks"; order: string[]; target: string}
+	"sync_sort:channels": EventHandler<{
-		| {type: "channels"; order: number[]; target: string}
+		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;