@rbxts/tether 1.4.3 → 1.4.5

package/out/emitters/client-emitter.luau

@@ -33,7 +33,7 @@ do
 			error("[tether::error] Cannot emit message from client to client")
 		end
 		task.spawn(function()
-			local _binding = self.master:runClientMiddlewares(message, data, player)
+			local _binding = self.master:runClientSendMiddlewares(message, data, player)
 			local dropRequest = _binding[1]
 			local newData = _binding[2]
 			if dropRequest then
@@ -80,7 +80,7 @@ do
 			error("[tether::error] Cannot emit message from client to all clients")
 		end
 		task.spawn(function()
-			local _binding = self.master:runClientMiddlewares(message, data)
+			local _binding = self.master:runClientSendMiddlewares(message, data)
 			local dropRequest = _binding[1]
 			local newData = _binding[2]
 			if dropRequest then

package/out/emitters/message-emitter.d.ts

@@ -29,13 +29,17 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     static create<MessageData>(options?: Partial<MessageEmitterOptions<MessageData>>, meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
     private constructor();
     /** @hidden */
-    runClientMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], player?: Player | Player[]): [boolean, MessageData[Kind]];
+    runClientSendMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], player?: Player | Player[]): [boolean, MessageData[Kind]];
     /** @hidden */
-    runServerMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind]): [boolean, MessageData[Kind]];
+    runServerSendMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind]): [boolean, MessageData[Kind]];
     /** @hidden */
     onRemoteFire(isServer: boolean, serializedPackets: SerializedPacket[], player?: Player): void;
+    private runServerReceiveMiddlewares;
+    private runClientReceiveMiddlewares;
     private validateData;
     private executeFunctions;
     private executeEventCallbacks;
+    private executeServerCallback;
+    private executeClientCallback;
     private deserializeAndValidate;
 }

package/out/emitters/message-emitter.luau

@@ -84,7 +84,7 @@ do
 		end
 		return emitter
 	end
-	function MessageEmitter:runClientMiddlewares(message, data, player)
+	function MessageEmitter:runClientSendMiddlewares(message, data, player)
 		if not self:validateData(message, data) then
 			return { true, data }
 		end
@@ -99,7 +99,7 @@ do
 		for _, globalMiddleware in self.middleware:getClientGlobal() do
 			local result = globalMiddleware(players, ctx)
 			if not self:validateData(message, ctx.data, "Invalid data after global client middleware") then
-				return { false, ctx.data }
+				return { true, ctx.data }
 			end
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Global client middleware")
@@ -109,7 +109,7 @@ do
 		for _, middleware in self.middleware:getClient(message) do
 			local result = middleware(players, ctx)
 			if not self:validateData(message, ctx.data, "Invalid data after client middleware") then
-				return { false, ctx.data }
+				return { true, ctx.data }
 			end
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Client middleware")
@@ -121,7 +121,7 @@ do
 		end
 		return { false, ctx.data }
 	end
-	function MessageEmitter:runServerMiddlewares(message, data)
+	function MessageEmitter:runServerSendMiddlewares(message, data)
 		if not self:validateData(message, data) then
 			return { true, data }
 		end
@@ -134,7 +134,7 @@ do
 		}
 		for _, globalMiddleware in self.middleware:getServerGlobal() do
 			if not self:validateData(message, ctx.data, "Invalid data after global server middleware") then
-				return { false, ctx.data }
+				return { true, ctx.data }
 			end
 			local result = globalMiddleware(ctx)
 			if result == DropRequest then
@@ -144,7 +144,7 @@ do
 		end
 		for _, middleware in self.middleware:getServer(message) do
 			if not self:validateData(message, ctx.data, "Invalid data after server middleware") then
-				return { false, ctx.data }
+				return { true, ctx.data }
 			end
 			local result = middleware(ctx)
 			if result == DropRequest then
@@ -167,6 +167,52 @@ do
 			self:executeFunctions(isServer, message, packet)
 		end
 	end
+	function MessageEmitter:runServerReceiveMiddlewares(message, player, data)
+		local ctx = {
+			message = message,
+			data = data,
+			getRawData = function()
+				return self.serdes:serializePacket(message, data)
+			end,
+		}
+		for _, middleware in self.middleware:getServerReceive(message) do
+			local result = middleware(player, ctx)
+			if not self:validateData(message, ctx.data, "Invalid data after server receive middleware") then
+				return { true, ctx.data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Server receive middleware")
+				return { true, ctx.data }
+			end
+		end
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
+		end
+		return { false, ctx.data }
+	end
+	function MessageEmitter:runClientReceiveMiddlewares(message, data)
+		local ctx = {
+			message = message,
+			data = data,
+			getRawData = function()
+				return self.serdes:serializePacket(message, data)
+			end,
+		}
+		for _, middleware in self.middleware:getClientReceive(message) do
+			local result = middleware(ctx)
+			if not self:validateData(message, ctx.data, "Invalid data after client receive middleware") then
+				return { true, ctx.data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Client receive middleware")
+				return { true, ctx.data }
+			end
+		end
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
+		end
+		return { false, ctx.data }
+	end
 	function MessageEmitter:validateData(message, data, requestDropReason)
 		if requestDropReason == nil then
 			requestDropReason = "Invalid data"
@@ -188,9 +234,9 @@ do
 		if functions == nil then
 			return nil
 		end
-		local packet = self:deserializeAndValidate(message, serializedPacket)
+		local data = self:deserializeAndValidate(message, serializedPacket)
 		for callback in functions do
-			callback(packet)
+			self:executeClientCallback(callback, message, data)
 		end
 	end
 	function MessageEmitter:executeEventCallbacks(isServer, message, serializedPacket, player)
@@ -200,21 +246,39 @@ do
 		if callbacks == nil then
 			return nil
 		end
-		local packet = self:deserializeAndValidate(message, serializedPacket)
+		local data = self:deserializeAndValidate(message, serializedPacket)
 		for callback in callbacks do
 			if isServer then
 				local _arg0 = player ~= nil
 				assert(_arg0)
-				callback(player, packet)
+				self:executeServerCallback(callback, player, message, data)
 			else
-				callback(packet)
+				self:executeClientCallback(callback, message, data)
 			end
 		end
 	end
+	function MessageEmitter:executeServerCallback(callback, player, message, data)
+		local _binding = self:runServerReceiveMiddlewares(message, player, data)
+		local dropRequest = _binding[1]
+		local newData = _binding[2]
+		if dropRequest then
+			return nil
+		end
+		callback(player, newData)
+	end
+	function MessageEmitter:executeClientCallback(callback, message, data)
+		local _binding = self:runClientReceiveMiddlewares(message, data)
+		local dropRequest = _binding[1]
+		local newData = _binding[2]
+		if dropRequest then
+			return nil
+		end
+		callback(newData)
+	end
 	function MessageEmitter:deserializeAndValidate(message, serializedPacket)
-		local packet = self.serdes:deserializePacket(message, serializedPacket)
-		self:validateData(message, packet)
-		return packet
+		local data = self.serdes:deserializePacket(message, serializedPacket)
+		self:validateData(message, data)
+		return data
 	end
 end
 return {

package/out/emitters/server-emitter.luau

@@ -31,7 +31,7 @@ do
 			error("[tether::error] Cannot emit message from server to server")
 		end
 		task.spawn(function()
-			local _binding = self.master:runServerMiddlewares(message, data)
+			local _binding = self.master:runServerSendMiddlewares(message, data)
 			local dropRequest = _binding[1]
 			local newData = _binding[2]
 			if dropRequest then

package/out/middleware.d.ts

@@ -20,9 +20,17 @@ type RequestDropCallback = (message: BaseMessage, reason?: string) => void;
 export declare class MiddlewareProvider<MessageData> {
     private readonly clientGlobalMiddlewares;
     private readonly serverGlobalMiddlewares;
-    private readonly clientMiddlewares;
-    private readonly serverMiddlewares;
+    private readonly clientSendMiddlewares;
+    private readonly serverSendMiddlewares;
+    private readonly serverReceiveMiddlewares;
+    private readonly clientReceiveMiddlewares;
     private readonly requestDroppedCallbacks;
+    /**
+     * Registers a callback to be called whenever a message is dropped.
+     * The callback will receive the message that was dropped and an optional reason string.
+     *
+     * @returns A function that can be called to unregister the callback.
+     */
     onRequestDropped(callback: RequestDropCallback): () => void;
     /** @hidden */
     notifyRequestDropped(message: BaseMessage, reason?: string): void;
@@ -34,9 +42,16 @@ export declare class MiddlewareProvider<MessageData> {
     getClientGlobal<Data>(): ClientMiddleware<Data>[];
     /** @hidden */
     getServerGlobal<Data>(): ServerMiddleware<Data>[];
+    /** @hidden */
+    getClientReceive<Kind extends keyof MessageData>(message: Kind & BaseMessage): ServerMiddleware<MessageData[Kind]>[];
+    /** @hidden */
+    getServerReceive<Kind extends keyof MessageData>(message: Kind & BaseMessage): ClientMiddleware<MessageData[Kind]>[];
     useClient<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[] | ClientMiddleware | readonly ClientMiddleware[], order?: number): this;
     useServer<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[] | ServerMiddleware | readonly ServerMiddleware[], order?: number): this;
     useShared<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: SharedMiddleware<MessageData[Kind]> | readonly SharedMiddleware<MessageData[Kind]>[] | SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
+    useClientReceive<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[] | ServerMiddleware | readonly ServerMiddleware[], order?: number): this;
+    useServerReceive<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[] | ClientMiddleware | readonly ClientMiddleware[], order?: number): this;
+    useSharedReceive<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: SharedMiddleware<MessageData[Kind]> | readonly SharedMiddleware<MessageData[Kind]>[] | SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
     useClientGlobal(middlewares: ClientMiddleware | readonly ClientMiddleware[], order?: number): this;
     useServerGlobal(middlewares: ServerMiddleware | readonly ServerMiddleware[], order?: number): this;
     useSharedGlobal(middlewares: SharedMiddleware | readonly SharedMiddleware[], order?: number): this;

package/out/middleware.luau

@@ -16,8 +16,10 @@ do
 	function MiddlewareProvider:constructor()
 		self.clientGlobalMiddlewares = {}
 		self.serverGlobalMiddlewares = {}
-		self.clientMiddlewares = {}
-		self.serverMiddlewares = {}
+		self.clientSendMiddlewares = {}
+		self.serverSendMiddlewares = {}
+		self.serverReceiveMiddlewares = {}
+		self.clientReceiveMiddlewares = {}
 		self.requestDroppedCallbacks = {}
 	end
 	function MiddlewareProvider:onRequestDropped(callback)
@@ -40,16 +42,18 @@ do
 		end
 	end
 	function MiddlewareProvider:getClient(message)
-		if self.clientMiddlewares[message] == nil then
-			self.clientMiddlewares[message] = {}
+		local _exp = self.clientSendMiddlewares
+		if _exp[message] == nil then
+			_exp[message] = {}
 		end
-		return self.clientMiddlewares[message]
+		return _exp[message]
 	end
 	function MiddlewareProvider:getServer(message)
-		if self.serverMiddlewares[message] == nil then
-			self.serverMiddlewares[message] = {}
+		local _exp = self.serverSendMiddlewares
+		if _exp[message] == nil then
+			_exp[message] = {}
 		end
-		return self.serverMiddlewares[message]
+		return _exp[message]
 	end
 	function MiddlewareProvider:getClientGlobal()
 		return self.clientGlobalMiddlewares
@@ -57,6 +61,20 @@ do
 	function MiddlewareProvider:getServerGlobal()
 		return self.serverGlobalMiddlewares
 	end
+	function MiddlewareProvider:getClientReceive(message)
+		local _exp = self.clientReceiveMiddlewares
+		if _exp[message] == nil then
+			_exp[message] = {}
+		end
+		return _exp[message]
+	end
+	function MiddlewareProvider:getServerReceive(message)
+		local _exp = self.serverReceiveMiddlewares
+		if _exp[message] == nil then
+			_exp[message] = {}
+		end
+		return _exp[message]
+	end
 	function MiddlewareProvider:useClient(message, middlewares, order)
 		local messageMiddleware = self:getClient(message)
 		local _middlewares = middlewares
@@ -110,6 +128,59 @@ do
 		self:useServer(message, server, order)
 		return self:useClient(message, client, order)
 	end
+	function MiddlewareProvider:useClientReceive(message, middlewares, order)
+		local messageMiddleware = self:getClientReceive(message)
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #messageMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useClientReceive(message, middleware, order)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useServerReceive(message, middlewares, order)
+		local messageMiddleware = self:getServerReceive(message)
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #messageMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useServerReceive(message, middleware, order)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useSharedReceive(message, middlewares, order)
+		local client = middlewares
+		local _middlewares = middlewares
+		local _exp = (if type(_middlewares) == "function" then { middlewares } else middlewares)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(middleware)
+			return function(_, ctx)
+				return middleware(ctx)
+			end
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local server = _newValue
+		self:useServerReceive(message, server, order)
+		return self:useClientReceive(message, client, order)
+	end
 	function MiddlewareProvider:useClientGlobal(middlewares, order)
 		local globalMiddleware = self:getClientGlobal()
 		local _middlewares = middlewares

package/out/relayer.luau

@@ -23,7 +23,7 @@ do
 end
 local sendUnreliableMessage
 do
-	local name = "unreliableMessage"
+	local name = "sendUnreliableMessage"
 	local existing = ReplicatedStorage:FindFirstChild(name)
 	local remote = (existing or Instance.new("UnreliableRemoteEvent", ReplicatedStorage))
 	if existing == nil then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "main": "out/init.luau",
   "scripts": {
     "setup-rokit": "rokit trust lune-org/lune && rokit trust rojo-rbx/rojo && rokit install",