@rbxts/tether 1.1.2 → 1.1.3

package/README.md

@@ -91,9 +91,9 @@ export function rateLimit(interval: number): SharedMiddleware {
 ```ts
 import type { ServerMiddleware } from "@rbxts/tether";
 
-export function incrementNumberData<T extends number>(): ServerMiddleware<T> {
-  return () => (data, updateData) =>
-    updateData(data as T + 1 as T); // sets the data to be used by the any subsequent middlewares as well as sent through the remote
+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);
 }
 ```
 
@@ -111,8 +111,10 @@ messaging.middleware
   // the data associated with the message at runtime using type guards
   .useServer(Message.Test, [BuiltinMiddlewares.validateServer()])
   // logs every message fired
-  .useServerGlobal([logServer()]);
-  .useClientGlobal([logClient()]);
+  .useServerGlobal([logServer()])
+  .useClientGlobal([logClient()])
+  .useServer(Message.Test, [incrementNumberData()]) // error! - data for Message.Test is not a number 
+  .useServerGlobal([incrementNumberData()]); // error! - global data type is always 'unknown', we cannot guarantee a number
 
 export const enum Message {
   Test

package/out/message-emitter.d.ts

@@ -1,8 +1,12 @@
 import { Modding } from "@flamework/core";
-import { type SerializerMetadata } from "@rbxts/flamework-binary-serializer";
+import { DataType, type SerializerMetadata } from "@rbxts/flamework-binary-serializer";
 import Destroyable from "@rbxts/destroyable";
 import { MiddlewareProvider } from "./middleware";
-import type { ClientMessageCallback, ServerMessageCallback } from "./structs";
+import type { ClientMessageCallback, ServerMessageCallback, BaseMessage } from "./structs";
+interface TetherPacket<Data> {
+    readonly message: DataType.u8;
+    readonly data?: Data;
+}
 export declare class MessageEmitter<MessageData> extends Destroyable {
     readonly middleware: MiddlewareProvider<MessageData>;
     private readonly clientCallbacks;
@@ -12,17 +16,17 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     private clientEvents;
     /** @metadata macro */
     static create<MessageData>(metaForEachMessage?: Modding.Many<{
-        [Kind in keyof MessageData]: MessageData[Kind] extends undefined ? undefined : Modding.Many<SerializerMetadata<MessageData[Kind]>>;
+        [Kind in keyof MessageData]: MessageData[Kind] extends undefined ? undefined : Modding.Many<SerializerMetadata<TetherPacket<MessageData[Kind]>>>;
     }>): MessageEmitter<MessageData>;
     private constructor();
     /**.
      * @returns A destructor function that disconnects the callback from the message
      */
-    onServerMessage<Kind extends keyof MessageData>(message: Kind, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
+    onServerMessage<Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
     /**.
      * @returns A destructor function that disconnects the callback from the message
      */
-    onClientMessage<Kind extends keyof MessageData>(message: Kind, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
+    onClientMessage<Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
     private on;
     /**
      * Emits a message to all connected clients
@@ -31,7 +35,7 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
      * @param data The data associated with the message
      * @param unreliable Whether the message should be sent unreliably
      */
-    emitServer<Kind extends keyof MessageData>(message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    emitServer<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean): void;
     /**
      * Emits a message to a specific client
      *
@@ -40,7 +44,7 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
      * @param data The data associated with the message
      * @param unreliable Whether the message should be sent unreliably
      */
-    emitClient<Kind extends keyof MessageData>(player: Player, message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    emitClient<Kind extends keyof MessageData>(player: Player, message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean): void;
     /**
      * Emits a message to all connected clients
      *
@@ -48,7 +52,7 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
      * @param data The data associated with the message
      * @param unreliable Whether the message should be sent unreliably
      */
-    emitAllClients<Kind extends keyof MessageData>(message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    emitAllClients<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean): void;
     private initialize;
     private getPacket;
     /** @metadata macro */
@@ -57,3 +61,4 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     private createMessageSerializer;
     private getSerializer;
 }
+export {};

package/out/message-emitter.luau

@@ -42,14 +42,14 @@ do
 			self.serverEvents = GlobalEvents:createServer({}, {
 				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
 				incoming = {
-					sendServerMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+					sendServerMessage = { { t.interface({
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					})) }, nil },
-					sendUnreliableServerMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+					}) }, nil },
+					sendUnreliableServerMessage = { { t.interface({
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					})) }, nil },
+					}) }, nil },
 				},
 				incomingUnreliable = {
 					sendUnreliableServerMessage = true,
@@ -65,14 +65,14 @@ do
 			self.clientEvents = GlobalEvents:createClient({}, {
 				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
 				incoming = {
-					sendClientMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+					sendClientMessage = { { t.interface({
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					})) }, nil },
-					sendUnreliableClientMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+					}) }, nil },
+					sendUnreliableClientMessage = { { t.interface({
 						buffer = t.typeof("buffer"),
 						blobs = t.array(t.any),
-					})) }, nil },
+					}) }, nil },
 				},
 				incomingUnreliable = {
 					sendUnreliableClientMessage = true,
@@ -96,7 +96,7 @@ do
 			if meta == nil then
 				continue
 			end
-			emitter:addSerializer(kind, meta)
+			emitter:addSerializer(tonumber(kind), meta)
 		end
 		return emitter:initialize()
 	end
@@ -149,7 +149,7 @@ do
 			end
 		end
 		local send = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
-		send(message, self:getPacket(message, data))
+		send(self:getPacket(message, data))
 	end
 	function MessageEmitter:emitClient(player, message, data, unreliable)
 		if unreliable == nil then
@@ -172,7 +172,7 @@ do
 			end
 		end
 		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-		send(player, message, self:getPacket(message, data))
+		send(player, self:getPacket(message, data))
 	end
 	function MessageEmitter:emitAllClients(message, data, unreliable)
 		if unreliable == nil then
@@ -199,18 +199,13 @@ do
 			end
 		end
 		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-		send:broadcast(message, self:getPacket(message, data))
+		send:broadcast(self:getPacket(message, data))
 	end
 	function MessageEmitter:initialize()
 		if RunService:IsClient() then
-			self.janitor:Add(self.clientEvents.sendClientMessage:connect(function(sentMessage, packet)
-				local _clientCallbacks = self.clientCallbacks
-				local _sentMessage = sentMessage
-				local _condition = _clientCallbacks[_sentMessage]
-				if _condition == nil then
-					_condition = {}
-				end
-				local messageCallbacks = _condition
+			self.janitor:Add(self.clientEvents.sendClientMessage:connect(function(serializedPacket)
+				local sentMessage = buffer.readu8(serializedPacket.buffer, 0)
+				local messageCallbacks = self.clientCallbacks[sentMessage] or {}
 				-- ▼ ReadonlySet.size ▼
 				local _size = 0
 				for _ in messageCallbacks do
@@ -221,20 +216,15 @@ do
 					return nil
 				end
 				local serializer = self:getSerializer(sentMessage)
-				local data = if packet ~= nil then serializer.deserialize(packet.buffer, packet.blobs) else nil
+				local packet = serializer.deserialize(serializedPacket.buffer, serializedPacket.blobs)
 				for callback in messageCallbacks do
-					callback(data)
+					callback(packet.data)
 				end
 			end))
 		else
-			self.janitor:Add(self.serverEvents.sendServerMessage:connect(function(player, sentMessage, packet)
-				local _serverCallbacks = self.serverCallbacks
-				local _sentMessage = sentMessage
-				local _condition = _serverCallbacks[_sentMessage]
-				if _condition == nil then
-					_condition = {}
-				end
-				local messageCallbacks = _condition
+			self.janitor:Add(self.serverEvents.sendServerMessage:connect(function(player, serializedPacket)
+				local sentMessage = buffer.readu8(serializedPacket.buffer, 0)
+				local messageCallbacks = self.serverCallbacks[sentMessage] or {}
 				-- ▼ ReadonlySet.size ▼
 				local _size = 0
 				for _ in messageCallbacks do
@@ -245,9 +235,9 @@ do
 					return nil
 				end
 				local serializer = self:getSerializer(sentMessage)
-				local data = if packet ~= nil then serializer.deserialize(packet.buffer, packet.blobs) else nil
+				local packet = serializer.deserialize(serializedPacket.buffer, serializedPacket.blobs)
 				for callback in messageCallbacks do
-					callback(player, data)
+					callback(player, packet.data)
 				end
 			end))
 		end
@@ -255,7 +245,10 @@ do
 	end
 	function MessageEmitter:getPacket(message, data)
 		local serializer = self:getSerializer(message)
-		return if data == nil then nil else serializer.serialize(data)
+		return serializer.serialize({
+			message = message,
+			data = data,
+		})
 	end
 	function MessageEmitter:addSerializer(message, meta)
 		self.serializers[message] = self:createMessageSerializer(meta)
@@ -264,7 +257,7 @@ do
 		return createBinarySerializer(meta)
 	end
 	function MessageEmitter:getSerializer(message)
-		return self.serializers[tostring(message)]
+		return self.serializers[message]
 	end
 end
 return {

package/out/middleware.d.ts

@@ -14,16 +14,16 @@ export declare class MiddlewareProvider<MessageData> {
     private readonly clientMiddlewares;
     private readonly serverMiddlewares;
     /** @hidden */
-    getClient<Kind extends keyof MessageData>(message: Kind): ClientMiddleware<MessageData[Kind]>[];
+    getClient<Kind extends keyof MessageData>(message: Kind & BaseMessage): ClientMiddleware<MessageData[Kind]>[];
     /** @hidden */
-    getServer<Kind extends keyof MessageData>(message: Kind): ServerMiddleware<MessageData[Kind]>[];
+    getServer<Kind extends keyof MessageData>(message: Kind & BaseMessage): ServerMiddleware<MessageData[Kind]>[];
     /** @hidden */
     getClientGlobal<Data>(): ClientMiddleware<Data>[];
     /** @hidden */
     getServerGlobal<Data>(): ServerMiddleware<Data>[];
-    useClient<Kind extends keyof MessageData>(message: Kind, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[], order?: number): this;
-    useServer<Kind extends keyof MessageData>(message: Kind, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[], order?: number): this;
-    useShared<Kind extends keyof MessageData>(message: Kind, middlewares: SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
+    useClient<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[], order?: number): this;
+    useServer<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[], order?: number): this;
+    useShared<Kind extends keyof MessageData>(message: Kind & BaseMessage, middlewares: 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/structs.d.ts

@@ -2,12 +2,12 @@ import type { Networking } from "@flamework/networking";
 export type MessageCallback<T = unknown> = ServerMessageCallback<T> | ClientMessageCallback<T>;
 export type ClientMessageCallback<T = unknown> = (data: T) => void;
 export type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
-export type BaseMessage = number | string | symbol;
+export type BaseMessage = number;
 export interface SerializedPacket {
     readonly buffer: buffer;
     readonly blobs: defined[];
 }
-export type MessageEvent = (kind: BaseMessage, packet?: SerializedPacket) => void;
+export type MessageEvent = (packet: SerializedPacket) => void;
 export type UnreliableMessageEvent = Networking.Unreliable<MessageEvent>;
 export interface ServerEvents {
     sendServerMessage: MessageEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",