@rbxts/tether 1.0.3 → 1.0.32

package/README.md

@@ -5,7 +5,7 @@ A message-based networking solution for Roblox with automatic binary serializati
 ```ts
 import { 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,8 +18,6 @@ export interface MessageData {
     readonly n: DataType.u8;
   };
 }
-
-messageEmitter.addSerializer<Message.TEST>(Message.TEST);
 ```
 
 > [!CAUTION]

package/out/index.d.ts

@@ -2,17 +2,17 @@ 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;
-/** @metadata macro */
-export declare function createMessageEmitter<MessageData>(metaForEachMessage?: Modding.Many<{
-    [Kind in keyof MessageData]: Modding.Many<SerializerMetadata<MessageData[Kind]>>;
-}>): MessageEmitter<MessageData> | undefined;
-declare class MessageEmitter<MessageData> {
+export declare class MessageEmitter<MessageData> {
     private readonly clientCallbacks;
     private readonly serverCallbacks;
     private readonly serializers;
     private readonly serverEvents;
     private readonly clientEvents;
-    constructor();
+    /** @metadata macro */
+    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;

package/out/init.luau

@@ -1,20 +1,11 @@
 -- 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()
---* @metadata macro 
+local GlobalEvents = Networking.createEvent("@rbxts/tether:init@GlobalEvents")
 local MessageEmitter
-local function createMessageEmitter(metaForEachMessage)
-	if metaForEachMessage == nil then
-		return nil
-	end
-	local emitter = MessageEmitter.new()
-	for kind, meta in pairs(metaForEachMessage) do
-		emitter:addSerializer(kind, meta)
-	end
-end
 do
 	MessageEmitter = setmetatable({}, {
 		__tostring = function()
@@ -31,10 +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
+			print(kind, meta)
+			emitter:addSerializer(kind, meta)
 		end
+		return emitter
 	end
 	function MessageEmitter:addSerializer(message, meta)
 		self.serializers[message] = self:createMessageSerializer(meta)
@@ -162,5 +209,5 @@ do
 	end
 end
 return {
-	createMessageEmitter = createMessageEmitter,
+	MessageEmitter = MessageEmitter,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.0.3",
+  "version": "1.0.32",
   "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",