@rbxts/tether 1.0.2 → 1.0.4

package/README.md

@@ -3,9 +3,9 @@ A message-based networking solution for Roblox with automatic binary serializati
 
 ### In `shared/messaging.ts`
 ```ts
-import { DataType } from "@rbxts/flamework-binary-serializer";
+import type { DataType } from "@rbxts/flamework-binary-serializer";
 
-export const messageEmitter = new MessageEmitter<Message, MessageData>;
+export const messageEmitter = MessageEmitter.create<MessageData>();
 messageEmitter.initialize();
 
 export const enum Message {
@@ -18,12 +18,10 @@ export interface MessageData {
     readonly n: DataType.u8;
   };
 }
-
-messageEmitter.addSerializer<Message.TOGGLE_MOVEMENT>(Message.TOGGLE_MOVEMENT);
 ```
 
 > [!CAUTION]
-> Every single message kind must implement an interface for it's data (in the example that would be the object with the `foo` and `bar` fields) as well as call `MessageEmitter.addSerializer()`. Messages will not work if you don't do this.
+> Every single message kind must implement an interface for it's data (in the example that would be the object with the `foo` and `bar` fields). Message serialization (as well as your message itself) will not work if you don't do this.
 
 ### Server
 ```ts

package/out/index.d.ts

@@ -2,22 +2,25 @@ import { Modding } from "@flamework/core";
 import { type SerializerMetadata } from "@rbxts/flamework-binary-serializer";
 type ClientMessageCallback<T = unknown> = (data: T) => void;
 type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
-type BaseMessage = number | string;
-export declare class MessageEmitter<Message extends BaseMessage, MessageData extends Record<Message, unknown>> {
+export declare class MessageEmitter<MessageData> {
     private readonly clientCallbacks;
     private readonly serverCallbacks;
     private readonly serializers;
     private readonly serverEvents;
     private readonly clientEvents;
-    constructor();
     /** @metadata macro */
-    addSerializer<Kind extends Message>(message: Kind, meta?: Modding.Many<SerializerMetadata<MessageData[Kind]>>): void;
+    static create<MessageData>(metaForEachMessage?: Modding.Many<{
+        [Kind in keyof MessageData]: Modding.Many<SerializerMetadata<MessageData[Kind]>>;
+    }>): MessageEmitter<MessageData>;
+    private constructor();
+    /** @metadata macro */
+    addSerializer<Kind extends keyof MessageData>(message: Kind, meta?: Modding.Many<SerializerMetadata<MessageData[Kind]>>): void;
     initialize(): RBXScriptConnection;
-    onServerMessage<Kind extends Message>(message: Kind, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
-    onClientMessage<Kind extends Message>(message: Kind, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
-    emitServer<Kind extends Message>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
-    emitClient<Kind extends Message>(player: Player, message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
-    emitAllClients<Kind extends Message>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
+    onServerMessage<Kind extends keyof MessageData>(message: Kind, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
+    onClientMessage<Kind extends keyof MessageData>(message: Kind, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
+    emitServer<Kind extends keyof MessageData>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
+    emitClient<Kind extends keyof MessageData>(player: Player, message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
+    emitAllClients<Kind extends keyof MessageData>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
     private getPacket;
     /** @metadata macro */
     private createMessageSerializer;

package/out/init.luau

@@ -1,9 +1,10 @@
 -- 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 createBinarySerializer = TS.import(script, TS.getModule(script, "@rbxts", "flamework-binary-serializer").out).createBinarySerializer
 local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
-local GlobalEvents = Networking.createEvent()
+local GlobalEvents = Networking.createEvent("@rbxts/tether:init@GlobalEvents")
 local MessageEmitter
 do
 	MessageEmitter = setmetatable({}, {
@@ -21,11 +22,66 @@ do
 		self.serverCallbacks = {}
 		self.serializers = {}
 		if RunService:IsServer() then
-			self.serverEvents = GlobalEvents:createServer({})
+			self.serverEvents = GlobalEvents:createServer({}, {
+				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
+				incoming = {
+					sendServerMessage = { { t.union(t.string, t.number), t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					}) }, nil },
+					sendUnreliableServerMessage = { { t.union(t.string, t.number), t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					}) }, nil },
+				},
+				incomingUnreliable = {
+					sendUnreliableServerMessage = true,
+				},
+				outgoingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
+				outgoingUnreliable = {
+					sendUnreliableClientMessage = true,
+				},
+				namespaceIds = {},
+				namespaces = {},
+			})
 		else
-			self.clientEvents = GlobalEvents:createClient({})
+			self.clientEvents = GlobalEvents:createClient({}, {
+				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
+				incoming = {
+					sendClientMessage = { { t.union(t.string, t.number), t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					}) }, nil },
+					sendUnreliableClientMessage = { { t.union(t.string, t.number), t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					}) }, nil },
+				},
+				incomingUnreliable = {
+					sendUnreliableClientMessage = true,
+				},
+				outgoingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
+				outgoingUnreliable = {
+					sendUnreliableServerMessage = true,
+				},
+				namespaceIds = {},
+				namespaces = {},
+			})
 		end
 	end
+	function MessageEmitter:create(metaForEachMessage)
+		if metaForEachMessage == nil then
+			warn("[Tether]: Failed to generate serializer metadata for MessageEmitter")
+		end
+		local emitter = MessageEmitter.new()
+		if metaForEachMessage == nil then
+			return emitter
+		end
+		for kind, meta in pairs(metaForEachMessage) do
+			emitter:addSerializer(kind, meta)
+		end
+		return emitter
+	end
 	function MessageEmitter:addSerializer(message, meta)
 		self.serializers[message] = self:createMessageSerializer(meta)
 	end
@@ -148,7 +204,7 @@ do
 		return createBinarySerializer(meta)
 	end
 	function MessageEmitter:getSerializer(message)
-		return self.serializers[message]
+		return self.serializers[tostring(message)]
 	end
 end
 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",
@@ -14,7 +14,7 @@
     "message"
   ],
   "repository": {
-    "url": "https://github.com/R-unic/tether.git"
+    "url": "git+https://github.com/R-unic/tether.git"
   },
   "author": "runicly",
   "license": "ISC",
@@ -30,8 +30,9 @@
   "devDependencies": {
     "@rbxts/compiler-types": "^3.0.0-types.0",
     "@rbxts/types": "^1.0.835",
+    "rbxts-transformer-flamework": "latest",
     "roblox-ts": "^3.0.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.5.3"
   },
   "dependencies": {
     "@flamework/core": "^1.2.3",