@rbxts/tether 1.2.9 → 1.3.1

package/out/builtin-middlewares.d.ts

@@ -1,5 +1,5 @@
 import { Modding } from "@flamework/core";
-import type { SerializerMetadata } from "@rbxts/flamework-binary-serializer";
+import type { SerializerMetadata } from "@rbxts/serio";
 import type { Any } from "ts-toolbelt";
 import { type SharedMiddleware } from "./middleware";
 export declare namespace BuiltinMiddlewares {

package/out/builtin-middlewares.luau

@@ -37,8 +37,12 @@ do
 			throwError = true
 		end
 		return function(ctx)
-			local rawData = ctx.getRawData()
-			local totalSize = buffer.len(rawData.buffer) + #rawData.blobs * BLOB_SIZE
+			local _binding = ctx.getRawData()
+			local buf = _binding.buf
+			local blobs = _binding.blobs
+			local bufferSize = if buf == nil then 0 else buffer.len(buf)
+			local blobsSize = if blobs == nil then 0 else #blobs * BLOB_SIZE
+			local totalSize = bufferSize + blobsSize
 			if totalSize > maxBytes then
 				return if throwError then error(`[@rbxts/tether]: Message '{ctx.message}' exceeded maximum packet size of {maxBytes} bytes`) else DropRequest
 			end
@@ -84,15 +88,17 @@ do
 			local message = _param.message
 			local data = _param.data
 			local getRawData = _param.getRawData
-			local rawData = getRawData()
-			local bufferSize = buffer.len(rawData.buffer)
-			local blobsSize = #rawData.blobs * BLOB_SIZE
+			local _binding = getRawData()
+			local buf = _binding.buf
+			local blobs = _binding.blobs
+			local bufferSize = if buf == nil then 0 else buffer.len(buf)
+			local blobsSize = if blobs == nil then 0 else #blobs * BLOB_SIZE
 			local schemaString = if schema ~= nil then " " .. table.concat(string.split(repr(schema[1], {
 				pretty = true,
 			}), "\n"), "\n ") else "unknown"
 			local text = { "\n", horizontalLine, "\n", "Packet sent to ", (if RunService:IsServer() then "client" else "server"), "!\n", " - Message: ", message, "\n", " - Data: ", repr(data, {
 				pretty = true,
-			}), "\n", " - Raw data:\n", "   - Buffer: ", bufferToString(rawData.buffer), "\n", "   - Blobs: ", repr(rawData.blobs, {
+			}), "\n", " - Raw data:\n", "   - Buffer: ", bufferToString(buf), "\n", "   - Blobs: ", repr(blobs, {
 				pretty = false,
 				robloxClassName = true,
 			}), "\n", " - Packet size: ", bufferSize + blobsSize, " bytes\n", "   - Buffer: ", bufferSize, " bytes\n", "   - Blobs: ", blobsSize, " bytes\n", " - Schema: ", schemaString, "\n", horizontalLine, "\n" }

package/out/message-emitter.luau

@@ -2,16 +2,16 @@
 local TS = _G[script]
 local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
 local Networking = TS.import(script, TS.getModule(script, "@flamework", "networking").out).Networking
-local createBinarySerializer = TS.import(script, TS.getModule(script, "@rbxts", "flamework-binary-serializer").out).createBinarySerializer
 local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local Players = _services.Players
 local RunService = _services.RunService
 local Destroyable = TS.import(script, TS.getModule(script, "@rbxts", "destroyable").out).default
+local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
+local createSerializer = TS.import(script, TS.getModule(script, "@rbxts", "serio").out).default
 local repr = TS.import(script, TS.getModule(script, "@rbxts", "repr").out)
 local _middleware = TS.import(script, script.Parent, "middleware")
 local DropRequest = _middleware.DropRequest
 local MiddlewareProvider = _middleware.MiddlewareProvider
-local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
 local remotes = Networking.createEvent("@rbxts/tether:message-emitter@remotes")
 local noServerListen = "[@rbxts/tether]: Cannot listen to server message from client"
 local noClientListen = "[@rbxts/tether]: Cannot listen to client message from server"
@@ -262,16 +262,16 @@ do
 			self.serverEvents = remotes:createServer({}, {
 				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
 				incoming = {
-					sendServerMessage = { { t.interface({
-						messageBuffer = t.typeof("buffer"),
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableServerMessage = { { t.interface({
-						messageBuffer = t.typeof("buffer"),
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
+					sendServerMessage = { { t.array(t.interface({
+						messageBuf = t.typeof("buffer"),
+						buf = t.optional(t.typeof("buffer")),
+						blobs = t.optional(t.array(t.any)),
+					})) }, nil },
+					sendUnreliableServerMessage = { { t.array(t.interface({
+						messageBuf = t.typeof("buffer"),
+						buf = t.optional(t.typeof("buffer")),
+						blobs = t.optional(t.array(t.any)),
+					})) }, nil },
 				},
 				incomingUnreliable = {
 					sendUnreliableServerMessage = true,
@@ -287,16 +287,16 @@ do
 			self.clientEvents = remotes:createClient({}, {
 				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
 				incoming = {
-					sendClientMessage = { { t.interface({
-						messageBuffer = t.typeof("buffer"),
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableClientMessage = { { t.interface({
-						messageBuffer = t.typeof("buffer"),
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
+					sendClientMessage = { { t.array(t.interface({
+						messageBuf = t.typeof("buffer"),
+						buf = t.optional(t.typeof("buffer")),
+						blobs = t.optional(t.array(t.any)),
+					})) }, nil },
+					sendUnreliableClientMessage = { { t.array(t.interface({
+						messageBuf = t.typeof("buffer"),
+						buf = t.optional(t.typeof("buffer")),
+						blobs = t.optional(t.array(t.any)),
+					})) }, 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.messageBuf) > 1 then
+				return warn("[@rbxts/tether]: Rejected packet because message buffer was larger than one byte")
+			end
+			local message = buffer.readu8(packet.messageBuf, 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()
@@ -524,7 +730,7 @@ do
 		local serializer = self:getSerializer(message)
 		local _packet = serializer
 		if _packet ~= nil then
-			_packet = _packet.deserialize(serializedPacket.buffer, serializedPacket.blobs)
+			_packet = _packet.deserialize(serializedPacket)
 		end
 		local packet = _packet
 		self:validateData(message, packet)
@@ -565,17 +771,17 @@ do
 	end
 	function MessageEmitter:getPacket(message, data)
 		local serializer = self:getSerializer(message)
-		local messageBuffer = buffer.create(1)
-		buffer.writeu8(messageBuffer, 0, message)
+		local messageBuf = buffer.create(1)
+		buffer.writeu8(messageBuf, 0, message)
 		if serializer == nil then
 			return {
-				messageBuffer = messageBuffer,
-				buffer = buffer.create(0),
+				messageBuf = messageBuf,
+				buf = buffer.create(0),
 				blobs = {},
 			}
 		end
 		local _object = {
-			messageBuffer = messageBuffer,
+			messageBuf = messageBuf,
 		}
 		for _k, _v in serializer.serialize(data) do
 			_object[_k] = _v
@@ -586,7 +792,7 @@ do
 		self.serializers[message] = self:createMessageSerializer(meta)
 	end
 	function MessageEmitter:createMessageSerializer(meta)
-		return createBinarySerializer(meta)
+		return createSerializer(meta)
 	end
 	function MessageEmitter:getSerializer(message)
 		return self.serializers[message]

package/out/structs.d.ts

@@ -1,32 +1,41 @@
 import { Modding } from "@flamework/core";
 import type { Networking } from "@flamework/networking";
-import type { SerializerMetadata } from "@rbxts/flamework-binary-serializer";
+import type { SerializerMetadata, SerializedData, Transform, Vector, String, u8, u16, u32, i8, i16, i32, f16, f24, f32, f64 } from "@rbxts/serio";
 export type MessageCallback<T = unknown> = ServerMessageCallback<T> | ClientMessageCallback<T>;
 export type ClientMessageCallback<T = unknown> = (data: T) => void;
 export type ClientMessageFunctionCallback<T = unknown, R = unknown> = (data: T) => R;
 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 SerializedPacket {
-    readonly messageBuffer: buffer;
-    readonly buffer: buffer;
-    readonly blobs: defined[];
+export interface PacketInfo {
+    readonly packet: SerializedPacket;
+    readonly unreliable: boolean;
 }
-export type MessageEvent = (packet: SerializedPacket) => void;
+export interface SerializedPacket extends SerializedData {
+    readonly messageBuf: buffer;
+}
+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;
 }
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+type ReplaceByMapWithDepth<T, Depth extends number = 11> = [
+    Depth
+] extends [never] ? T : T extends Vector ? Vector3 : T extends Transform ? CFrame : T extends String ? string : T extends u8 | u16 | u32 | i8 | i16 | i32 | f16 | f24 | f32 | f64 ? number : T extends any[] ? ReplaceByMapWithDepth<T[number], Prev[Depth]>[] : T extends object ? {
+    [K in keyof T]: ReplaceByMapWithDepth<T[K], Prev[Depth]>;
+} : T;
 export interface MessageMetadata<MessageData, Kind extends keyof MessageData> {
-    readonly guard: Modding.Generic<MessageData[Kind], "guard">;
+    readonly guard: Modding.Generic<ReplaceByMapWithDepth<MessageData[Kind]>, "guard">;
     readonly serializerMetadata: MessageData[Kind] extends undefined ? undefined : Modding.Many<SerializerMetadata<MessageData[Kind]>>;
 }
 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>;
 };
+export {};

package/out/utility.d.ts

@@ -1 +1 @@
-export declare function bufferToString(buf: buffer): string;
+export declare function bufferToString(buf?: buffer): string;

package/out/utility.luau

@@ -1,27 +1,28 @@
 -- Compiled with roblox-ts v3.0.0
 local function bufferToString(buf)
 	local s = { "{ " }
-	do
-		local i = 0
-		local _shouldIncrement = false
-		while true do
-			if _shouldIncrement then
-				i += 1
-			else
-				_shouldIncrement = true
-			end
-			if not (i < buffer.len(buf)) then
-				break
-			end
-			local byte = buffer.readu8(buf, i)
-			local _arg0 = tostring(byte)
-			table.insert(s, _arg0)
-			if i < buffer.len(buf) - 1 then
-				table.insert(s, ", ")
+	if buf ~= nil then
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < buffer.len(buf)) then
+					break
+				end
+				local byte = buffer.readu8(buf, i)
+				local _arg0 = tostring(byte)
+				table.insert(s, _arg0)
+				local _arg0_1 = if i < buffer.len(buf) - 1 then ", " else ""
+				table.insert(s, _arg0_1)
 			end
 		end
 	end
-	table.insert(s, " }")
+	table.insert(s, "}")
 	return table.concat(s, "")
 end
 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.2.9",
+  "version": "1.3.1",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",
@@ -32,15 +32,15 @@
   "devDependencies": {
     "@rbxts/compiler-types": "^3.0.0-types.0",
     "@rbxts/types": "^1.0.835",
-    "rbxts-transformer-flamework": "^1.2.4",
+    "rbxts-transformer-flamework": "^1.3.1",
     "roblox-ts": "^3.0.0",
     "typescript": "^5.5.3"
   },
   "dependencies": {
-    "@flamework/core": "^1.2.4",
-    "@flamework/networking": "^1.2.4",
+    "@flamework/core": "^1.3.1",
+    "@flamework/networking": "^1.3.1",
     "@rbxts/destroyable": "^1.0.1",
-    "@rbxts/flamework-binary-serializer": "^0.6.0",
+    "@rbxts/serio": "^1.0.5",
     "@rbxts/flamework-meta-utils": "^1.0.4",
     "@rbxts/object-utils": "^1.0.4",
     "@rbxts/repr": "^1.0.1",