@rbxts/tether 1.3.12 → 1.3.14

package/README.md

@@ -182,7 +182,7 @@ import type { ServerMiddleware } from "@rbxts/tether";
 
 export function incrementNumberData(): ServerMiddleware<number> {
   // sets the data to be used by the any subsequent middlewares as well as sent through the remote
-  return ({ data, updateData }) => updateData(data + 1);
+  return (ctx) => ctx.data++;
 }
 ```
 

package/out/index.d.ts

@@ -1,3 +1,3 @@
 export { MessageEmitter } from "./message-emitter";
 export { BuiltinMiddlewares } from "./builtin-middlewares";
-export { DropRequest, type ClientMiddleware, type ServerMiddleware, type SharedMiddleware, type Middleware } from "./middleware";
+export { DropRequest, type ClientMiddleware, type ServerMiddleware, type SharedMiddleware, type Middleware, type MiddlewareContext } from "./middleware";

package/out/message-emitter.d.ts

@@ -18,8 +18,6 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     private serverQueue;
     private clientBroadcastQueue;
     private clientQueue;
-    private serverEvents;
-    private clientEvents;
     /** @metadata macro */
     static create<MessageData>(options?: Partial<MessageEmitterOptions>, meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
     private constructor();

package/out/message-emitter.luau

@@ -1,9 +1,8 @@
 -- Compiled with roblox-ts v3.0.0
 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 _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local Players = _services.Players
+local ReplicatedStorage = _services.ReplicatedStorage
 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"))
@@ -12,7 +11,11 @@ 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 remotes = Networking.createEvent("@rbxts/tether:message-emitter@remotes")
+local IS_LUNE = string.sub(_VERSION, 1, 4) == "Lune"
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
+setLuneContext("both")
 local noServerListen = "[@rbxts/tether]: Cannot listen to server message from client"
 local noClientListen = "[@rbxts/tether]: Cannot listen to client message from server"
 local metaGenerationFailed = "[@rbxts/tether]: Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas"
@@ -23,6 +26,26 @@ local defaultMesssageEmitterOptions = {
 	batchRemotes = true,
 	batchRate = 1 / 24,
 }
+local sendMessage
+do
+	local name = "sendMessage"
+	local existing = ReplicatedStorage:FindFirstChild(name)
+	local remote = (existing or Instance.new("RemoteEvent", ReplicatedStorage))
+	if existing == nil then
+		remote.Name = name
+	end
+	sendMessage = remote
+end
+local sendUnreliableMessage
+do
+	local name = "unreliableMessage"
+	local existing = ReplicatedStorage:FindFirstChild(name)
+	local remote = (existing or Instance.new("UnreliableRemoteEvent", ReplicatedStorage))
+	if existing == nil then
+		remote.Name = name
+	end
+	sendUnreliableMessage = remote
+end
 local MessageEmitter
 do
 	local super = Destroyable
@@ -255,60 +278,7 @@ do
 			table.clear(self.clientCallbacks)
 			table.clear(self.serverCallbacks)
 			table.clear(self.serializers)
-			self.serverEvents = nil
-			self.clientEvents = nil
 		end)
-		if RunService:IsServer() then
-			self.serverEvents = remotes:createServer({}, {
-				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
-				incoming = {
-					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,
-				},
-				outgoingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
-				outgoingUnreliable = {
-					sendUnreliableClientMessage = true,
-				},
-				namespaceIds = {},
-				namespaces = {},
-			})
-		else
-			self.clientEvents = remotes:createClient({}, {
-				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
-				incoming = {
-					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,
-				},
-				outgoingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
-				outgoingUnreliable = {
-					sendUnreliableServerMessage = true,
-				},
-				namespaceIds = {},
-				namespaces = {},
-			})
-		end
 	end
 	function MessageEmitter:create(options, meta)
 		local emitter = MessageEmitter.new(Object.assign({}, defaultMesssageEmitterOptions, options))
@@ -329,19 +299,26 @@ do
 		return emitter:initialize()
 	end
 	function MessageEmitter:initialize()
+		setLuneContext("client")
 		if RunService:IsClient() then
-			self.janitor:Add(self.clientEvents.sendClientMessage:connect(function(serializedPacket)
-				return self:onRemoteFire(serializedPacket)
+			self.janitor:Add(sendMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self:onRemoteFire(false, serializedPacket)
 			end))
-			self.janitor:Add(self.clientEvents.sendUnreliableClientMessage:connect(function(serializedPacket)
-				return self:onRemoteFire(serializedPacket)
+			self.janitor:Add(sendUnreliableMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self:onRemoteFire(false, serializedPacket)
 			end))
-		else
-			self.janitor:Add(self.serverEvents.sendServerMessage:connect(function(player, serializedPacket)
-				return self:onRemoteFire(serializedPacket, player)
+		end
+		setLuneContext("server")
+		if RunService:IsServer() then
+			self.janitor:Add(sendMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self:onRemoteFire(true, serializedPacket, player)
 			end))
-			self.janitor:Add(self.serverEvents.sendUnreliableServerMessage:connect(function(player, serializedPacket)
-				return self:onRemoteFire(serializedPacket, player)
+			self.janitor:Add(sendUnreliableMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self:onRemoteFire(true, serializedPacket, player)
 			end))
 		end
 		local elapsed = 0
@@ -353,10 +330,11 @@ do
 		end
 		self.janitor:Add(RunService.Heartbeat:Connect(function(dt)
 			elapsed += dt
-			if elapsed >= batchRate then
-				elapsed -= batchRate
-				self:update()
+			if elapsed < batchRate then
+				return nil
 			end
+			elapsed -= batchRate
+			self:update()
 		end))
 		return self
 	end
@@ -427,10 +405,10 @@ do
 			-- ▲ ReadonlyArray.map ▲
 			local serverPackets = _newValue_4
 			if not (#unreliableServerPackets == 0) then
-				self.clientEvents.sendUnreliableServerMessage(unreliableServerPackets)
+				sendUnreliableMessage:FireServer(unpack(unreliableServerPackets))
 			end
 			if not (#serverPackets == 0) then
-				self.clientEvents.sendServerMessage(serverPackets)
+				sendMessage:FireServer(unpack(serverPackets))
 			end
 			self.serverQueue = {}
 			return nil
@@ -526,10 +504,10 @@ do
 			-- ▲ ReadonlyArray.map ▲
 			local broadcastPackets = _newValue_4
 			if not (#unreliableBroadcastPackets == 0) then
-				self.serverEvents.sendUnreliableClientMessage:broadcast(unreliableBroadcastPackets)
+				sendUnreliableMessage:FireAllClients(unpack(unreliableBroadcastPackets))
 			end
 			if not (#broadcastPackets == 0) then
-				self.serverEvents.sendClientMessage:broadcast(broadcastPackets)
+				sendMessage:FireAllClients(unpack(broadcastPackets))
 			end
 			self.clientBroadcastQueue = {}
 		end
@@ -582,10 +560,10 @@ do
 				-- ▲ ReadonlyArray.map ▲
 				local packets = _newValue_3
 				if not (#unreliablePackets == 0) then
-					self.serverEvents.sendUnreliableClientMessage(player, unreliablePackets)
+					sendUnreliableMessage:FireClient(player, unpack(unreliablePackets))
 				end
 				if not (#packets == 0) then
-					self.serverEvents.sendClientMessage(player, packets)
+					sendMessage:FireClient(player, unpack(packets))
 				end
 			end
 			self.clientQueue = {}
@@ -599,38 +577,34 @@ do
 		local ctx = {
 			message = message,
 			data = data,
-			updateData = function(newData)
-				data = newData
-				return nil
-			end,
 			getRawData = function()
 				return self:getPacket(message, data)
 			end,
 		}
 		for _, globalMiddleware in self.middleware:getClientGlobal() do
 			local result = globalMiddleware(players, ctx)
-			if not self:validateData(message, data, "Invalid data after global client middleware") then
-				return { false, data }
+			if not self:validateData(message, ctx.data, "Invalid data after global client middleware") then
+				return { false, ctx.data }
 			end
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Global client middleware")
-				return { true, data }
+				return { true, ctx.data }
 			end
 		end
 		for _, middleware in self.middleware:getClient(message) do
 			local result = middleware(players, ctx)
-			if not self:validateData(message, data, "Invalid data after client middleware") then
-				return { false, data }
+			if not self:validateData(message, ctx.data, "Invalid data after client middleware") then
+				return { false, ctx.data }
 			end
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Client middleware")
-				return { true, data }
+				return { true, ctx.data }
 			end
 		end
-		if not self:validateData(message, data) then
-			return { true, data }
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
 		end
-		return { false, data }
+		return { false, ctx.data }
 	end
 	function MessageEmitter:runServerMiddlewares(message, data)
 		if not self:validateData(message, data) then
@@ -639,38 +613,34 @@ do
 		local ctx = {
 			message = message,
 			data = data,
-			updateData = function(newData)
-				data = newData
-				return nil
-			end,
 			getRawData = function()
 				return self:getPacket(message, data)
 			end,
 		}
 		for _, globalMiddleware in self.middleware:getServerGlobal() do
-			if not self:validateData(message, data, "Invalid data after global server middleware") then
-				return { false, data }
+			if not self:validateData(message, ctx.data, "Invalid data after global server middleware") then
+				return { false, ctx.data }
 			end
 			local result = globalMiddleware(ctx)
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Global server middleware")
-				return { true, data }
+				return { true, ctx.data }
 			end
 		end
 		for _, middleware in self.middleware:getServer(message) do
-			if not self:validateData(message, data, "Invalid data after server middleware") then
-				return { false, data }
+			if not self:validateData(message, ctx.data, "Invalid data after server middleware") then
+				return { false, ctx.data }
 			end
 			local result = middleware(ctx)
 			if result == DropRequest then
 				self.middleware:notifyRequestDropped(message, "Server middleware")
-				return { true, data }
+				return { true, ctx.data }
 			end
 		end
-		if not self:validateData(message, data) then
-			return { true, data }
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
 		end
-		return { false, data }
+		return { false, ctx.data }
 	end
 	function MessageEmitter:validateData(message, data, requestDropReason)
 		if requestDropReason == nil then
@@ -686,18 +656,17 @@ do
 		end
 		return guardPassed
 	end
-	function MessageEmitter:onRemoteFire(serializedPackets, player)
+	function MessageEmitter:onRemoteFire(isServer, 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)
+			self:executeEventCallbacks(isServer, message, packet, player)
+			self:executeFunctions(isServer, message, packet)
 		end
 	end
-	function MessageEmitter:executeFunctions(message, serializedPacket)
-		local isServer = RunService:IsServer()
+	function MessageEmitter:executeFunctions(isServer, message, serializedPacket)
 		local functionsMap = if isServer then self.serverFunctions else self.clientFunctions
 		local _message = message
 		local functions = functionsMap[_message]
@@ -709,8 +678,7 @@ do
 			callback(packet)
 		end
 	end
-	function MessageEmitter:executeEventCallbacks(message, serializedPacket, player)
-		local isServer = RunService:IsServer()
+	function MessageEmitter:executeEventCallbacks(isServer, message, serializedPacket, player)
 		local callbacksMap = if isServer then self.serverCallbacks else self.clientCallbacks
 		local _message = message
 		local callbacks = callbacksMap[_message]

package/out/middleware.d.ts

@@ -13,8 +13,7 @@ export type SharedMiddleware<Data = unknown> = (ctx: MiddlewareContext<Data>) =>
 export type Middleware<Data = unknown> = ServerMiddleware<Data> & ClientMiddleware<Data> & SharedMiddleware<Data>;
 export interface MiddlewareContext<Data = unknown, Message extends BaseMessage = BaseMessage> {
     readonly message: Message;
-    readonly data: Readonly<Data>;
-    updateData: (newData: Data) => void;
+    data: Data;
     getRawData: () => SerializedPacket;
 }
 type RequestDropCallback = (message: BaseMessage, reason?: string) => void;
@@ -41,5 +40,11 @@ export declare class MiddlewareProvider<MessageData> {
     useClientGlobal(middlewares: ClientMiddleware | readonly ClientMiddleware[], order?: number): this;
     useServerGlobal(middlewares: ServerMiddleware | readonly ServerMiddleware[], order?: number): this;
     useSharedGlobal(middlewares: SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
+    deleteSharedGlobal<Kind extends keyof MessageData>(middlewares: SharedMiddleware<MessageData[Kind]> | readonly SharedMiddleware<MessageData[Kind]>[] | SharedMiddleware | readonly SharedMiddleware[]): void;
+    deleteClientGlobal<Kind extends keyof MessageData>(middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[] | ClientMiddleware | readonly ClientMiddleware[]): void;
+    deleteServerGlobal<Kind extends keyof MessageData>(middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[] | ServerMiddleware | readonly ServerMiddleware[]): void;
+    deleteShared<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: SharedMiddleware<MessageData[Kind]> | readonly SharedMiddleware<MessageData[Kind]>[] | SharedMiddleware | readonly SharedMiddleware[]): void;
+    deleteClient<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[] | ClientMiddleware | readonly ClientMiddleware[]): void;
+    deleteServer<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[] | ServerMiddleware | readonly ServerMiddleware[]): void;
 }
 export {};

package/out/middleware.luau

@@ -162,6 +162,96 @@ do
 		self:useClientGlobal(client, order)
 		return self:useServerGlobal(middlewares, order)
 	end
+	function MiddlewareProvider:deleteSharedGlobal(middlewares)
+		local server = 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 client = _newValue
+		self:deleteClientGlobal(client)
+		self:deleteServerGlobal(server)
+	end
+	function MiddlewareProvider:deleteClientGlobal(middlewares)
+		local clientMiddlewares = self:getClientGlobal()
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _middlewares_1 = middlewares
+			local _arg0 = (table.find(clientMiddlewares, _middlewares_1) or 0) - 1
+			table.remove(clientMiddlewares, _arg0 + 1)
+		else
+			for _, middleware in middlewares do
+				self:deleteClientGlobal(middleware)
+			end
+		end
+	end
+	function MiddlewareProvider:deleteServerGlobal(middlewares)
+		local serverMiddlewares = self:getServerGlobal()
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _middlewares_1 = middlewares
+			local _arg0 = (table.find(serverMiddlewares, _middlewares_1) or 0) - 1
+			table.remove(serverMiddlewares, _arg0 + 1)
+		else
+			for _, middleware in middlewares do
+				self:deleteServerGlobal(middleware)
+			end
+		end
+	end
+	function MiddlewareProvider:deleteShared(message, middlewares)
+		local server = 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 client = _newValue
+		self:deleteClient(message, client)
+		self:deleteServer(message, server)
+	end
+	function MiddlewareProvider:deleteClient(message, middlewares)
+		local clientMiddlewares = self:getClient(message)
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _middlewares_1 = middlewares
+			local _arg0 = (table.find(clientMiddlewares, _middlewares_1) or 0) - 1
+			table.remove(clientMiddlewares, _arg0 + 1)
+		else
+			for _, middleware in middlewares do
+				self:deleteClient(message, middleware)
+			end
+		end
+	end
+	function MiddlewareProvider:deleteServer(message, middlewares)
+		local serverMiddlewares = self:getServer(message)
+		local _middlewares = middlewares
+		if type(_middlewares) == "function" then
+			local _middlewares_1 = middlewares
+			local _arg0 = (table.find(serverMiddlewares, _middlewares_1) or 0) - 1
+			table.remove(serverMiddlewares, _arg0 + 1)
+		else
+			for _, middleware in middlewares do
+				self:deleteServer(message, middleware)
+			end
+		end
+	end
 end
 return {
 	DropRequest = DropRequest,

package/out/structs.d.ts

@@ -1,5 +1,4 @@
-import { Modding } from "@flamework/core";
-import type { Networking } from "@flamework/networking";
+import type { Modding } from "@flamework/core";
 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;
@@ -14,16 +13,7 @@ export interface PacketInfo {
 export interface SerializedPacket extends SerializedData {
     readonly messageBuf: buffer;
 }
-export type MessageEvent = (packets: SerializedPacket[]) => void;
-export type UnreliableMessageEvent = Networking.Unreliable<MessageEvent>;
-export interface ServerEvents {
-    readonly sendServerMessage: MessageEvent;
-    readonly sendUnreliableServerMessage: UnreliableMessageEvent;
-}
-export interface ClientEvents {
-    readonly sendClientMessage: MessageEvent;
-    readonly sendUnreliableClientMessage: UnreliableMessageEvent;
-}
+export type MessageEvent = (...packets: SerializedPacket[]) => void;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
 type ReplaceByMapWithDepth<T, Depth extends number = 11> = [
     Depth

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.3.12",
-  "main": "out/init.lua",
+  "version": "1.3.14",
+  "main": "out/init.luau",
   "scripts": {
-    "build": "rbxtsc",
-    "watch": "rbxtsc -w",
-    "prepublishOnly": "npm run build"
+    "setup-rokit": "rokit trust lune-org/lune && rokit trust rojo-rbx/rojo && rokit install",
+    "build": "npm run setup-rokit && rbxtsc ",
+    "prepublishOnly": "npm test && rbxtsc",
+    "test": "rbxtsc && npm run build -- -p tests && rojo build tests -o tests/test-environment.rbxl && lune run tests tests/test-environment.rbxl"
   },
   "keywords": [
     "roblox",
@@ -31,20 +32,19 @@
   },
   "devDependencies": {
     "@rbxts/compiler-types": "^3.0.0-types.0",
-    "@rbxts/types": "^1.0.835",
+    "@rbxts/types": "^1.0.856",
     "rbxts-transformer-flamework": "^1.3.1",
     "roblox-ts": "^3.0.0",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.3",
+    "ts-toolbelt": "^9.6.0"
   },
   "dependencies": {
     "@flamework/core": "^1.3.1",
-    "@flamework/networking": "^1.3.1",
     "@rbxts/destroyable": "^1.0.1",
     "@rbxts/flamework-meta-utils": "^1.0.6",
     "@rbxts/object-utils": "^1.0.4",
     "@rbxts/repr": "^1.0.1",
-    "@rbxts/serio": "^1.0.17",
-    "@rbxts/services": "^1.5.5",
-    "ts-toolbelt": "^9.6.0"
+    "@rbxts/serio": "^1.0.18",
+    "@rbxts/services": "^1.5.5"
   }
 }