@rbxts/tether 1.4.0 → 1.4.2

package/out/emitters/server-emitter.luau

@@ -0,0 +1,107 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local ContextualEmitter = TS.import(script, script.Parent, "contextual-emitter").ContextualEmitter
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
+local ServerEmitter
+do
+	local super = ContextualEmitter
+	ServerEmitter = setmetatable({}, {
+		__tostring = function()
+			return "ServerEmitter"
+		end,
+		__index = super,
+	})
+	ServerEmitter.__index = ServerEmitter
+	function ServerEmitter.new(...)
+		local self = setmetatable({}, ServerEmitter)
+		return self:constructor(...) or self
+	end
+	function ServerEmitter:constructor(...)
+		super.constructor(self, ...)
+		self.context = "server"
+	end
+	function ServerEmitter:emit(message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsServer() then
+			error("[tether::error] Cannot emit message from server to server")
+		end
+		task.spawn(function()
+			local _binding = self.master:runServerMiddlewares(message, data)
+			local dropRequest = _binding[1]
+			local newData = _binding[2]
+			if dropRequest then
+				return nil
+			end
+			self.master.relayer:queueMessage(self.context, message, { message, newData, unreliable })
+		end)
+	end
+	function ServerEmitter:setCallback(message, returnMessage, callback)
+		if RunService:IsClient() then
+			error("[tether::error] Cannot listen to client message from server")
+		end
+		return self:on(message, function(player, data)
+			local returnValue = callback(player, data)
+			-- Defer the response emission to end of frame and swap context to avoid context check issues
+			-- task.defer guarantees response is sent by end of current frame, ensuring predictable timing in production
+			task.defer(function()
+				setLuneContext("server")
+				self.master.client:emit(player, returnMessage, returnValue)
+				setLuneContext("both")
+			end)
+		end)
+	end
+	function ServerEmitter:invoke(message, returnMessage, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsServer() then
+			error("[tether::error] Cannot invoke function from server to server")
+		end
+		local _binding = self.master
+		local clientFunctions = _binding.clientFunctions
+		local _returnMessage = returnMessage
+		if not (clientFunctions[_returnMessage] ~= nil) then
+			local _returnMessage_1 = returnMessage
+			clientFunctions[_returnMessage_1] = {}
+		end
+		local _returnMessage_1 = returnMessage
+		local functions = clientFunctions[_returnMessage_1]
+		local returnValue
+		local responseCallback = function(data)
+			returnValue = data
+			return returnValue
+		end
+		functions[responseCallback] = true
+		self:emit(message, data, unreliable)
+		return TS.Promise.new(function(resolve, reject)
+			-- awful
+			local frames = 0
+			while true do
+				local _condition = returnValue == nil
+				if _condition then
+					local _original = frames
+					frames += 1
+					_condition = _original < 400
+				end
+				if not _condition then
+					break
+				end
+				RunService.Heartbeat:Wait()
+			end
+			if frames == 400 then
+				return reject("[tether::error] Server function timed out (no response)")
+			end
+			-- clean up the callback after receiving the response
+			functions[responseCallback] = nil
+			resolve(returnValue)
+		end)
+	end
+end
+return {
+	ServerEmitter = ServerEmitter,
+}

package/out/index.d.ts

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

package/out/init.luau

@@ -1,7 +1,7 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local exports = {}
-exports.MessageEmitter = TS.import(script, script, "message-emitter").MessageEmitter
+exports.MessageEmitter = TS.import(script, script, "emitters", "message-emitter").MessageEmitter
 exports.BuiltinMiddlewares = TS.import(script, script, "builtin-middlewares").BuiltinMiddlewares
 exports.DropRequest = TS.import(script, script, "middleware").DropRequest
 return exports

package/out/logging.d.ts

@@ -0,0 +1,15 @@
+export declare const enum Error {
+    NoServerListen = "[tether::error] Cannot listen to server message from client",
+    NoClientListen = "[tether::error] Cannot listen to client message from server",
+    NoServerToServer = "[tether::error] Cannot emit message from server to server",
+    NoClientToClient = "[tether::error] Cannot emit message from client to client",
+    NoClientToAllClients = "[tether::error] Cannot emit message from client to all clients",
+    NoServerToServerFunction = "[tether::error] Cannot invoke function from server to server",
+    NoClientToClientFunction = "[tether::error] Cannot invoke function from client to client",
+    ServerFunctionTimeout = "[tether::error] Server function timed out (no response)",
+    ClientFunctionTimeout = "[tether::error] Client function timed out (no response)"
+}
+export declare const enum Warning {
+    MessageBufferTooLong = "[tether::warning] Rejected packet because message buffer was larger than one byte",
+    MetaGenerationFailed = "[tether::warning] Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas"
+}

package/out/logging.luau

@@ -0,0 +1,4 @@
+-- Compiled with roblox-ts v3.0.0
+local errorTag = "[tether::error] "
+local warnTag = "[tether::warning] "
+return nil

package/out/relayer.d.ts

@@ -0,0 +1,16 @@
+import type { BaseMessage } from "./structs";
+import type { MessageEmitter } from "./emitters/message-emitter";
+export type ServerQueuedMessageData<MessageData> = [keyof MessageData & BaseMessage, MessageData[keyof MessageData], boolean];
+export type ClientQueuedMessageData<MessageData> = [Player | Player[], ...ServerQueuedMessageData<MessageData>];
+export type QueuedMessageData<MessageData> = ClientQueuedMessageData<MessageData> | ServerQueuedMessageData<MessageData>;
+export declare class Relayer<MessageData> {
+    private readonly emitter;
+    private serverQueue;
+    private clientBroadcastQueue;
+    private clientQueue;
+    constructor(emitter: MessageEmitter<MessageData>);
+    queueMessage<K extends keyof MessageData>(context: "client" | "server" | true, message: K & BaseMessage, data: QueuedMessageData<MessageData>): void;
+    /** Send all queued data across the network simultaneously */
+    relayAll(): void;
+    private relay;
+}

package/out/relayer.luau

@@ -0,0 +1,214 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local ReplicatedStorage = _services.ReplicatedStorage
+local RunService = _services.RunService
+local _utility = TS.import(script, script.Parent, "utility")
+local getAllPacketsWhich = _utility.getAllPacketsWhich
+local isReliable = _utility.isReliable
+local isUnreliable = _utility.isUnreliable
+local shouldBatch = _utility.shouldBatch
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
+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 Relayer
+do
+	Relayer = setmetatable({}, {
+		__tostring = function()
+			return "Relayer"
+		end,
+	})
+	Relayer.__index = Relayer
+	function Relayer.new(...)
+		local self = setmetatable({}, Relayer)
+		return self:constructor(...) or self
+	end
+	function Relayer:constructor(emitter)
+		self.emitter = emitter
+		self.serverQueue = {}
+		self.clientBroadcastQueue = {}
+		self.clientQueue = {}
+		setLuneContext("client")
+		if RunService:IsClient() then
+			self.emitter.trash:add(sendMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(false, serializedPacket)
+			end))
+			self.emitter.trash:add(sendUnreliableMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(false, serializedPacket)
+			end))
+		end
+		setLuneContext("server")
+		if RunService:IsServer() then
+			self.emitter.trash:add(sendMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(true, serializedPacket, player)
+			end))
+			self.emitter.trash:add(sendUnreliableMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(true, serializedPacket, player)
+			end))
+		end
+		local elapsed = 0
+		local _binding = self.emitter.options
+		local batchRemotes = _binding.batchRemotes
+		local batchRate = _binding.batchRate
+		if not batchRemotes then
+			return self
+		end
+		self.emitter.trash:add(RunService.Heartbeat:Connect(function(dt)
+			elapsed += dt
+			if elapsed < batchRate then
+				return nil
+			end
+			elapsed -= batchRate
+			self:relayAll()
+		end))
+	end
+	function Relayer:queueMessage(context, message, data)
+		local queue = if context == "client" then self.clientQueue elseif context == true then self.clientBroadcastQueue else self.serverQueue
+		local _data = data
+		table.insert(queue, _data)
+		if not shouldBatch(message, self.emitter.options) then
+			self:relayAll()
+		end
+	end
+	function Relayer:relayAll()
+		if RunService:IsClient() then
+			return self:relay(function(...)
+				local packets = { ... }
+				return sendMessage:FireServer(unpack(packets))
+			end, function(...)
+				local packets = { ... }
+				return sendUnreliableMessage:FireServer(unpack(packets))
+			end, self.serverQueue, function()
+				self.serverQueue = {}
+				return self.serverQueue
+			end)
+		end
+		self:relay(function(...)
+			local packets = { ... }
+			return sendMessage:FireAllClients(unpack(packets))
+		end, function(...)
+			local packets = { ... }
+			return sendUnreliableMessage:FireAllClients(unpack(packets))
+		end, self.clientBroadcastQueue, function()
+			self.clientBroadcastQueue = {}
+			return self.clientBroadcastQueue
+		end)
+		local playerPacketInfos = {}
+		local addClientPacket = function(player, packetInfo)
+			local _player = player
+			local _condition = playerPacketInfos[_player]
+			if _condition == nil then
+				_condition = {}
+			end
+			local packetInfos = _condition
+			local _packetInfo = packetInfo
+			table.insert(packetInfos, _packetInfo)
+			local _player_1 = player
+			playerPacketInfos[_player_1] = packetInfos
+		end
+		for _, _binding in self.clientQueue do
+			local player = _binding[1]
+			local message = _binding[2]
+			local data = _binding[3]
+			local unreliable = _binding[4]
+			local packet = self.emitter.serdes:serializePacket(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.clientQueue == 0) then
+			for player, packetInfos in playerPacketInfos do
+				if #packetInfos == 0 then
+					continue
+				end
+				local unreliablePackets = getAllPacketsWhich(packetInfos, isUnreliable)
+				local packets = getAllPacketsWhich(packetInfos, isReliable)
+				if not (#unreliablePackets == 0) then
+					sendUnreliableMessage:FireClient(player, unpack(unreliablePackets))
+				end
+				if not (#packets == 0) then
+					sendMessage:FireClient(player, unpack(packets))
+				end
+			end
+			self.clientQueue = {}
+		end
+	end
+	function Relayer:relay(send, sendUnreliable, queue, clearQueue)
+		if #queue == 0 then
+			return nil
+		end
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#queue)
+		local _callback = function(messageData)
+			local message
+			local data
+			local unreliable
+			local _arg0 = messageData[1]
+			if typeof(_arg0) == "Instance" then
+				local _binding = messageData
+				message = _binding[2]
+				data = _binding[3]
+				unreliable = _binding[4]
+			else
+				local _binding = messageData
+				message = _binding[1]
+				data = _binding[2]
+				unreliable = _binding[3]
+			end
+			local packet = self.emitter.serdes:serializePacket(message, data)
+			return {
+				packet = packet,
+				unreliable = unreliable,
+			}
+		end
+		for _k, _v in queue do
+			_newValue[_k] = _callback(_v, _k - 1, queue)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local packetInfos = _newValue
+		local unreliablePackets = getAllPacketsWhich(packetInfos, isUnreliable)
+		local packets = getAllPacketsWhich(packetInfos, isReliable)
+		if not (#unreliablePackets == 0) then
+			sendUnreliable(unpack(unreliablePackets))
+		end
+		if not (#packets == 0) then
+			send(unpack(packets))
+		end
+		clearQueue()
+	end
+end
+return {
+	Relayer = Relayer,
+}

package/out/serdes.d.ts

@@ -0,0 +1,13 @@
+import type { Modding } from "@flamework/core";
+import type { Serializer, SerializerMetadata } from "@rbxts/serio";
+import type { BaseMessage, SerializedPacket } from "./structs";
+export declare class Serdes<MessageData> {
+    serializers: Partial<Record<keyof MessageData, Serializer<MessageData[keyof MessageData]>>>;
+    serializePacket<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind]): SerializedPacket;
+    deserializePacket<K extends keyof MessageData>(message: K & BaseMessage, serializedPacket: SerializedPacket): MessageData[K] | undefined;
+    /** @metadata macro */
+    addSerializer<K extends keyof MessageData>(message: K & BaseMessage, meta?: Modding.Many<SerializerMetadata<MessageData[K]>>): void;
+    /** @metadata macro */
+    createMessageSerializer<Kind extends keyof MessageData>(meta?: Modding.Many<SerializerMetadata<MessageData[Kind]>>): Serializer<MessageData[Kind]>;
+    getSerializer<Kind extends keyof MessageData>(message: Kind & BaseMessage): Serializer<MessageData[Kind] | undefined> | undefined;
+}

package/out/serdes.luau

@@ -0,0 +1,58 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local createSerializer = TS.import(script, TS.getModule(script, "@rbxts", "serio").out).default
+local createMessageBuffer = TS.import(script, script.Parent, "utility").createMessageBuffer
+local Serdes
+do
+	Serdes = setmetatable({}, {
+		__tostring = function()
+			return "Serdes"
+		end,
+	})
+	Serdes.__index = Serdes
+	function Serdes.new(...)
+		local self = setmetatable({}, Serdes)
+		return self:constructor(...) or self
+	end
+	function Serdes:constructor()
+		self.serializers = {}
+	end
+	function Serdes:serializePacket(message, data)
+		local serializer = self:getSerializer(message)
+		local messageBuf = createMessageBuffer(message)
+		if serializer == nil then
+			return {
+				messageBuf = messageBuf,
+				buf = buffer.create(0),
+				blobs = {},
+			}
+		end
+		local _object = {
+			messageBuf = messageBuf,
+		}
+		for _k, _v in serializer.serialize(data) do
+			_object[_k] = _v
+		end
+		return _object
+	end
+	function Serdes:deserializePacket(message, serializedPacket)
+		local serializer = self:getSerializer(message)
+		local _result = serializer
+		if _result ~= nil then
+			_result = _result.deserialize(serializedPacket)
+		end
+		return _result
+	end
+	function Serdes:addSerializer(message, meta)
+		self.serializers[message] = self:createMessageSerializer(meta)
+	end
+	function Serdes:createMessageSerializer(meta)
+		return createSerializer(meta)
+	end
+	function Serdes:getSerializer(message)
+		return self.serializers[message]
+	end
+end
+return {
+	Serdes = Serdes,
+}

package/out/structs.d.ts

@@ -1,10 +1,11 @@
 import type { Modding } from "@flamework/core";
 import type { SerializerMetadata, SerializedData, Transform, Vector, String, u8, u16, u24, u32, i8, i16, i24, i32, f16, f24, f32, f64 } from "@rbxts/serio";
 export type MessageCallback<T = unknown> = ServerMessageCallback<T> | ClientMessageCallback<T>;
+export type FunctionMessageCallback<T = unknown, R = unknown> = ServerFunctionMessageCallback<T, R> | ClientFunctionMessageCallback<T, R>;
 export type ClientMessageCallback<T = unknown> = (data: T) => void;
-export type ClientMessageFunctionCallback<T = unknown, R = unknown> = (data: T) => R;
+export type ClientFunctionMessageCallback<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 ServerFunctionMessageCallback<T = unknown, R = unknown> = (player: Player, data: T) => R;
 export type BaseMessage = number;
 export interface PacketInfo {
     readonly packet: SerializedPacket;

package/out/utility.d.ts

@@ -1 +1,13 @@
+import type { BaseMessage, PacketInfo, SerializedPacket } from "./structs";
+import type { MessageEmitterOptions } from "./emitters/message-emitter";
 export declare function bufferToString(buf?: buffer): string;
+export declare function encodeMessage(message: BaseMessage): number;
+export declare function decodeMessage(encoded: number): BaseMessage;
+export declare function writeMessage(buf: buffer, message: BaseMessage): void;
+export declare function readMessage(packet: SerializedPacket | buffer): BaseMessage;
+export declare function createMessageBuffer(message: BaseMessage): buffer;
+export declare function getAllPacketsWhich(infos: PacketInfo[], predicate: (info: PacketInfo) => boolean): SerializedPacket[];
+export declare function isUnreliable(info: PacketInfo): boolean;
+export declare function isReliable(info: PacketInfo): boolean;
+export declare function getPacket(info: PacketInfo): SerializedPacket;
+export declare function shouldBatch<MessageData>(message: keyof MessageData & BaseMessage, options: MessageEmitterOptions<MessageData>): boolean;

package/out/utility.luau

@@ -1,4 +1,5 @@
 -- Compiled with roblox-ts v3.0.0
+local COEFF = 0xFA
 local function bufferToString(buf)
 	local s = { "{ " }
 	if buf ~= nil then
@@ -25,6 +26,79 @@ local function bufferToString(buf)
 	table.insert(s, "}")
 	return table.concat(s, "")
 end
+local function encodeMessage(message)
+	message = bit32.band((bit32.bxor(message, COEFF)), 0xFF)
+	return bit32.bor((bit32.lshift(message, 3)), (bit32.arshift(message, 5)))
+end
+local function decodeMessage(encoded)
+	encoded = bit32.bor((bit32.arshift(encoded, 3)), (bit32.lshift(encoded, 5)))
+	return bit32.band((bit32.bxor(encoded, COEFF)), 0xFF)
+end
+local function writeMessage(buf, message)
+	local _arg0 = buffer.len(buf) == 1
+	assert(_arg0)
+	buffer.writeu8(buf, 0, encodeMessage(message))
+end
+local function readMessage(packet)
+	local _packet = packet
+	local buf = if type(_packet) == "buffer" then packet else packet.messageBuf
+	return decodeMessage(buffer.readu8(buf, 0))
+end
+local function createMessageBuffer(message)
+	local messageBuf = buffer.create(1)
+	writeMessage(messageBuf, message)
+	return messageBuf
+end
+local getPacket
+local function getAllPacketsWhich(infos, predicate)
+	local _infos = infos
+	local _predicate = predicate
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _length = 0
+	for _k, _v in _infos do
+		if _predicate(_v, _k - 1, _infos) == 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 ▲
+	return _newValue_1
+end
+local function isUnreliable(info)
+	return info.unreliable
+end
+local function isReliable(info)
+	return not info.unreliable
+end
+function getPacket(info)
+	return info.packet
+end
+local function shouldBatch(message, options)
+	local _condition = options.batchRemotes
+	if _condition then
+		local _doNotBatch = options.doNotBatch
+		local _message = message
+		_condition = not (_doNotBatch[_message] ~= nil)
+	end
+	return _condition
+end
 return {
 	bufferToString = bufferToString,
+	encodeMessage = encodeMessage,
+	decodeMessage = decodeMessage,
+	writeMessage = writeMessage,
+	readMessage = readMessage,
+	createMessageBuffer = createMessageBuffer,
+	getAllPacketsWhich = getAllPacketsWhich,
+	isUnreliable = isUnreliable,
+	isReliable = isReliable,
+	getPacket = getPacket,
+	shouldBatch = shouldBatch,
 }

package/package.json

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