@rbxts/tether 1.2.9 → 1.3.0

package/out/message-emitter.luau

@@ -262,16 +262,16 @@ do
 			self.serverEvents = remotes:createServer({}, {
 				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
 				incoming = {
-					sendServerMessage = { { t.interface({
+					sendServerMessage = { { t.array(t.interface({
 						messageBuffer = t.typeof("buffer"),
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableServerMessage = { { t.interface({
+					})) }, nil },
+					sendUnreliableServerMessage = { { t.array(t.interface({
 						messageBuffer = t.typeof("buffer"),
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					}) }, nil },
+					})) }, nil },
 				},
 				incomingUnreliable = {
 					sendUnreliableServerMessage = true,
@@ -287,16 +287,16 @@ do
 			self.clientEvents = remotes:createClient({}, {
 				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
 				incoming = {
-					sendClientMessage = { { t.interface({
+					sendClientMessage = { { t.array(t.interface({
 						messageBuffer = t.typeof("buffer"),
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableClientMessage = { { t.interface({
+					})) }, nil },
+					sendUnreliableClientMessage = { { t.array(t.interface({
 						messageBuffer = t.typeof("buffer"),
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					}) }, nil },
+					})) }, nil },
 				},
 				incomingUnreliable = {
 					sendUnreliableClientMessage = true,
@@ -361,31 +361,235 @@ do
 		return self
 	end
 	function MessageEmitter:update()
+		local getPacket = function(info)
+			return info.packet
+		end
+		if RunService:IsClient() then
+			if #self.serverQueue == 0 then
+				return nil
+			end
+			local _exp = self.serverQueue
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#_exp)
+			local _callback = function(_param)
+				local message = _param[1]
+				local data = _param[2]
+				local unreliable = _param[3]
+				local packet = self:getPacket(message, data)
+				return {
+					packet = packet,
+					unreliable = unreliable,
+				}
+			end
+			for _k, _v in _exp do
+				_newValue[_k] = _callback(_v, _k - 1, _exp)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local serverPacketInfos = _newValue
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue_1 = {}
+			local _callback_1 = function(info)
+				return info.unreliable
+			end
+			local _length = 0
+			for _k, _v in serverPacketInfos do
+				if _callback_1(_v, _k - 1, serverPacketInfos) == true then
+					_length += 1
+					_newValue_1[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue_2 = table.create(#_newValue_1)
+			for _k, _v in _newValue_1 do
+				_newValue_2[_k] = getPacket(_v, _k - 1, _newValue_1)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local unreliableServerPackets = _newValue_2
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue_3 = {}
+			local _callback_2 = function(info)
+				return not info.unreliable
+			end
+			local _length_1 = 0
+			for _k, _v in serverPacketInfos do
+				if _callback_2(_v, _k - 1, serverPacketInfos) == true then
+					_length_1 += 1
+					_newValue_3[_length_1] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue_4 = table.create(#_newValue_3)
+			for _k, _v in _newValue_3 do
+				_newValue_4[_k] = getPacket(_v, _k - 1, _newValue_3)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local serverPackets = _newValue_4
+			if not (#unreliableServerPackets == 0) then
+				self.clientEvents.sendUnreliableServerMessage(unreliableServerPackets)
+			end
+			if not (#serverPackets == 0) then
+				self.clientEvents.sendServerMessage(serverPackets)
+			end
+			self.serverQueue = {}
+			return nil
+		end
+		local clientPackets = {}
+		local addClientPacket = function(player, packetInfo)
+			local _player = player
+			local _condition = clientPackets[_player]
+			if _condition == nil then
+				_condition = {}
+			end
+			local packetList = _condition
+			local _packetInfo = packetInfo
+			table.insert(packetList, _packetInfo)
+			local _player_1 = player
+			clientPackets[_player_1] = packetList
+		end
 		for _, _binding in self.clientQueue do
 			local player = _binding[1]
 			local message = _binding[2]
 			local data = _binding[3]
 			local unreliable = _binding[4]
-			local remote = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-			remote(player, self:getPacket(message, data))
+			local packet = self:getPacket(message, data)
+			local info = {
+				packet = packet,
+				unreliable = unreliable,
+			}
+			if typeof(player) == "Instance" then
+				addClientPacket(player, info)
+			else
+				for _1, p in player do
+					addClientPacket(p, info)
+				end
+			end
 		end
-		self.clientQueue = {}
-		for _, _binding in self.clientBroadcastQueue do
-			local message = _binding[1]
-			local data = _binding[2]
-			local unreliable = _binding[3]
-			local remote = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-			remote:broadcast(self:getPacket(message, data))
+		if not (#self.clientBroadcastQueue == 0) then
+			local _exp = self.clientBroadcastQueue
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#_exp)
+			local _callback = function(_param)
+				local message = _param[1]
+				local data = _param[2]
+				local unreliable = _param[3]
+				local packet = self:getPacket(message, data)
+				return {
+					packet = packet,
+					unreliable = unreliable,
+				}
+			end
+			for _k, _v in _exp do
+				_newValue[_k] = _callback(_v, _k - 1, _exp)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local clientBroadcastPackets = _newValue
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue_1 = {}
+			local _callback_1 = function(info)
+				return info.unreliable
+			end
+			local _length = 0
+			for _k, _v in clientBroadcastPackets do
+				if _callback_1(_v, _k - 1, clientBroadcastPackets) == true then
+					_length += 1
+					_newValue_1[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue_2 = table.create(#_newValue_1)
+			for _k, _v in _newValue_1 do
+				_newValue_2[_k] = getPacket(_v, _k - 1, _newValue_1)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local unreliableBroadcastPackets = _newValue_2
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue_3 = {}
+			local _callback_2 = function(info)
+				return not info.unreliable
+			end
+			local _length_1 = 0
+			for _k, _v in clientBroadcastPackets do
+				if _callback_2(_v, _k - 1, clientBroadcastPackets) == true then
+					_length_1 += 1
+					_newValue_3[_length_1] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue_4 = table.create(#_newValue_3)
+			for _k, _v in _newValue_3 do
+				_newValue_4[_k] = getPacket(_v, _k - 1, _newValue_3)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			local broadcastPackets = _newValue_4
+			if not (#unreliableBroadcastPackets == 0) then
+				self.serverEvents.sendUnreliableClientMessage:broadcast(unreliableBroadcastPackets)
+			end
+			if not (#broadcastPackets == 0) then
+				self.serverEvents.sendClientMessage:broadcast(broadcastPackets)
+			end
+			self.clientBroadcastQueue = {}
 		end
-		self.clientBroadcastQueue = {}
-		for _, _binding in self.serverQueue do
-			local message = _binding[1]
-			local data = _binding[2]
-			local unreliable = _binding[3]
-			local remote = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
-			remote(self:getPacket(message, data))
+		if not (#self.clientQueue == 0) then
+			for player, packetInfo in clientPackets do
+				if #packetInfo == 0 then
+					continue
+				end
+				if #packetInfo == 0 then
+					continue
+				end
+				-- ▼ ReadonlyArray.filter ▼
+				local _newValue = {}
+				local _callback = function(info)
+					return info.unreliable
+				end
+				local _length = 0
+				for _k, _v in packetInfo do
+					if _callback(_v, _k - 1, packetInfo) == true then
+						_length += 1
+						_newValue[_length] = _v
+					end
+				end
+				-- ▲ ReadonlyArray.filter ▲
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue_1 = table.create(#_newValue)
+				for _k, _v in _newValue do
+					_newValue_1[_k] = getPacket(_v, _k - 1, _newValue)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local unreliablePackets = _newValue_1
+				-- ▼ ReadonlyArray.filter ▼
+				local _newValue_2 = {}
+				local _callback_1 = function(info)
+					return not info.unreliable
+				end
+				local _length_1 = 0
+				for _k, _v in packetInfo do
+					if _callback_1(_v, _k - 1, packetInfo) == true then
+						_length_1 += 1
+						_newValue_2[_length_1] = _v
+					end
+				end
+				-- ▲ ReadonlyArray.filter ▲
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue_3 = table.create(#_newValue_2)
+				for _k, _v in _newValue_2 do
+					_newValue_3[_k] = getPacket(_v, _k - 1, _newValue_2)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local packets = _newValue_3
+				if not (#unreliablePackets == 0) then
+					self.serverEvents.sendUnreliableClientMessage(player, unreliablePackets)
+				end
+				if not (#packets == 0) then
+					self.serverEvents.sendClientMessage(player, packets)
+				end
+			end
+			self.clientQueue = {}
 		end
-		self.serverQueue = {}
 	end
 	function MessageEmitter:runClientMiddlewares(message, data, player)
 		if not self:validateData(message, data) then
@@ -482,13 +686,15 @@ do
 		end
 		return guardPassed
 	end
-	function MessageEmitter:onRemoteFire(serializedPacket, player)
-		if buffer.len(serializedPacket.messageBuffer) > 1 then
-			return warn("[@rbxts/tether]: Rejected message because message buffer was larger than one byte")
+	function MessageEmitter:onRemoteFire(serializedPackets, player)
+		for _, packet in serializedPackets do
+			if buffer.len(packet.messageBuffer) > 1 then
+				return warn("[@rbxts/tether]: Rejected packet because message buffer was larger than one byte")
+			end
+			local message = buffer.readu8(packet.messageBuffer, 0)
+			self:executeEventCallbacks(message, packet, player)
+			self:executeFunctions(message, packet)
 		end
-		local message = buffer.readu8(serializedPacket.messageBuffer, 0)
-		self:executeEventCallbacks(message, serializedPacket, player)
-		self:executeFunctions(message, serializedPacket)
 	end
 	function MessageEmitter:executeFunctions(message, serializedPacket)
 		local isServer = RunService:IsServer()

package/out/structs.d.ts

@@ -7,20 +7,24 @@ export type ClientMessageFunctionCallback<T = unknown, R = unknown> = (data: T)
 export type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
 export type ServerMessageFunctionCallback<T = unknown, R = unknown> = (player: Player, data: T) => R;
 export type BaseMessage = number;
+export interface PacketInfo {
+    readonly packet: SerializedPacket;
+    readonly unreliable: boolean;
+}
 export interface SerializedPacket {
     readonly messageBuffer: buffer;
     readonly buffer: buffer;
     readonly blobs: defined[];
 }
-export type MessageEvent = (packet: SerializedPacket) => void;
+export type MessageEvent = (packets: SerializedPacket[]) => void;
 export type UnreliableMessageEvent = Networking.Unreliable<MessageEvent>;
 export interface ServerEvents {
-    sendServerMessage: MessageEvent;
-    sendUnreliableServerMessage: UnreliableMessageEvent;
+    readonly sendServerMessage: MessageEvent;
+    readonly sendUnreliableServerMessage: UnreliableMessageEvent;
 }
 export interface ClientEvents {
-    sendClientMessage: MessageEvent;
-    sendUnreliableClientMessage: UnreliableMessageEvent;
+    readonly sendClientMessage: MessageEvent;
+    readonly sendUnreliableClientMessage: UnreliableMessageEvent;
 }
 export interface MessageMetadata<MessageData, Kind extends keyof MessageData> {
     readonly guard: Modding.Generic<MessageData[Kind], "guard">;
@@ -28,5 +32,5 @@ export interface MessageMetadata<MessageData, Kind extends keyof MessageData> {
 }
 export type Guard<T = unknown> = (value: unknown) => value is T;
 export type MessageEmitterMetadata<MessageData> = {
-    [Kind in keyof MessageData]: MessageMetadata<MessageData, Kind>;
+    readonly [Kind in keyof MessageData]: MessageMetadata<MessageData, Kind>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",