@rbxts/tether 1.2.8 → 1.3.0

package/out/message-emitter.d.ts

@@ -13,11 +13,11 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     private readonly clientFunctions;
     private readonly serverCallbacks;
     private readonly serverFunctions;
-    private readonly clientQueue;
-    private readonly clientBroadcastQueue;
-    private readonly serverQueue;
     private readonly guards;
     private readonly serializers;
+    private serverQueue;
+    private clientBroadcastQueue;
+    private clientQueue;
     private serverEvents;
     private clientEvents;
     /** @metadata macro */

package/out/message-emitter.luau

@@ -48,11 +48,11 @@ do
 		self.clientFunctions = {}
 		self.serverCallbacks = {}
 		self.serverFunctions = {}
-		self.clientQueue = {}
-		self.clientBroadcastQueue = {}
-		self.serverQueue = {}
 		self.guards = {}
 		self.serializers = {}
+		self.serverQueue = {}
+		self.clientBroadcastQueue = {}
+		self.clientQueue = {}
 		self.server = {
 			on = function(message, callback)
 				if RunService:IsClient() then
@@ -83,6 +83,9 @@ do
 					local _serverQueue = self.serverQueue
 					local _arg0 = { message, newData, unreliable }
 					table.insert(_serverQueue, _arg0)
+					if not self.options.batchRemotes then
+						self:update()
+					end
 				end)
 			end,
 			invoke = TS.async(function(message, returnMessage, data, unreliable)
@@ -153,6 +156,9 @@ do
 					local _clientQueue = self.clientQueue
 					local _arg0 = { player, message, newData, unreliable }
 					table.insert(_clientQueue, _arg0)
+					if not self.options.batchRemotes then
+						self:update()
+					end
 				end)
 			end,
 			emitExcept = function(player, message, data, unreliable)
@@ -202,6 +208,9 @@ do
 					local _clientBroadcastQueue = self.clientBroadcastQueue
 					local _arg0 = { message, newData, unreliable }
 					table.insert(_clientBroadcastQueue, _arg0)
+					if not self.options.batchRemotes then
+						self:update()
+					end
 				end)
 			end,
 			invoke = TS.async(function(message, returnMessage, player, data, unreliable)
@@ -253,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,
@@ -278,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,
@@ -302,7 +311,7 @@ do
 		end
 	end
 	function MessageEmitter:create(options, meta)
-		local emitter = MessageEmitter.new(Object.assign({}, options, defaultMesssageEmitterOptions))
+		local emitter = MessageEmitter.new(Object.assign({}, defaultMesssageEmitterOptions, options))
 		if meta == nil then
 			warn(metaGenerationFailed)
 			return emitter:initialize()
@@ -336,41 +345,251 @@ do
 			end))
 		end
 		local elapsed = 0
-		RunService.Heartbeat:Connect(function(dt)
+		local _binding = self.options
+		local batchRemotes = _binding.batchRemotes
+		local batchRate = _binding.batchRate
+		if not batchRemotes then
+			return self
+		end
+		self.janitor:Add(RunService.Heartbeat:Connect(function(dt)
 			elapsed += dt
-			if elapsed >= self.options.batchRate then
-				elapsed -= self.options.batchRate
+			if elapsed >= batchRate then
+				elapsed -= batchRate
 				self:update()
 			end
-		end)
+		end))
 		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))
-		end
-		table.clear(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))
-		end
-		table.clear(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))
-		end
-		table.clear(self.serverQueue)
+			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
+		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
+		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
 	end
 	function MessageEmitter:runClientMiddlewares(message, data, player)
 		if not self:validateData(message, data) then
@@ -467,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.8",
+  "version": "1.3.0",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",