@axpecter/lync 2.2.0 → 2.2.1

package/README.md

@@ -17,7 +17,7 @@ Packets, queries, groups, validation, and rate limiting — all batched into one
 
 ```toml
 [dependencies]
-Lync = "axp3cter/lync@2.2.0"
+Lync = "axp3cter/lync@2.2.1"
 ```
 
 **npm (roblox-ts)**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@axpecter/lync",
-    "version": "2.2.0",
+    "version": "2.2.1",
     "description": "Buffer networking for Roblox. Delta compression, XOR framing, built-in security",
     "main": "src/init.luau",
     "types": "src/index.d.ts",

package/src/api/Packet.luau

@@ -39,24 +39,30 @@ end
 
 -- Public types -----------------------------------------------------------
 
-export type PacketHandle = {
-    send: (self: PacketHandle, data: any, target: any?) -> (),
-    on: (self: PacketHandle, fn: (...any) -> ()) -> Types.Connection,
-    once: (self: PacketHandle, fn: (...any) -> ()) -> Types.Connection,
-    wait: (self: PacketHandle) -> ...any,
-    name: (self: PacketHandle) -> string,
-    stats: (self: PacketHandle) -> Types.PacketStats,
+export type PacketHandle<T> = {
+    send: (self: PacketHandle<T>, data: T, target: any?) -> (),
+    on: (
+        self: PacketHandle<T>,
+        fn: (data: T, sender: Player?, timestamp: number?) -> ()
+    ) -> Types.Connection,
+    once: (
+        self: PacketHandle<T>,
+        fn: (data: T, sender: Player?, timestamp: number?) -> ()
+    ) -> Types.Connection,
+    wait: (self: PacketHandle<T>) -> (T, Player?, number?),
+    name: (self: PacketHandle<T>) -> string,
+    stats: (self: PacketHandle<T>) -> Types.PacketStats,
 }
 
 -- Public -----------------------------------------------------------------
 
 local Packet = {}
 
-function Packet.define(
+function Packet.define<T>(
     name: string,
-    codec: Types.InternalCodec<any>,
+    codec: Types.InternalCodec<T>,
     options: Types.PacketOptions?
-): PacketHandle
+): PacketHandle<T>
     local opts = options or ({} :: Types.PacketOptions)
     local isUnreliable = opts.unreliable or false
 
@@ -189,8 +195,11 @@ function Packet.define(
         bumpFires()
     end
 
+    type Self = PacketHandle<T>
+    type Listener = (data: T, sender: Player?, timestamp: number?) -> ()
+
     local handle = {
-        send = function(_self: PacketHandle, data: any, target: any?): ()
+        send = function(_self: Self, data: T, target: any?): ()
             if IS_SERVER then
                 sendFromServer(data, target)
             else
@@ -198,11 +207,11 @@ function Packet.define(
             end
         end,
 
-        on = function(_self: PacketHandle, fn: (...any) -> ()): Types.Connection
-            return reg.signal:connect(fn)
+        on = function(_self: Self, fn: Listener): Types.Connection
+            return reg.signal:connect(fn :: any)
         end,
 
-        once = function(_self: PacketHandle, fn: (...any) -> ()): Types.Connection
+        once = function(_self: Self, fn: Listener): Types.Connection
             local conn: Types.Connection
             conn = reg.signal:connect(function(...: any)
                 conn:disconnect()
@@ -211,15 +220,15 @@ function Packet.define(
             return conn
         end,
 
-        wait = function(_self: PacketHandle): ...any
+        wait = function(_self: Self): (T, Player?, number?)
             return reg.signal:wait()
         end,
 
-        name = function(_self: PacketHandle): string
+        name = function(_self: Self): string
             return reg.name
         end,
 
-        stats = function(_self: PacketHandle): Types.PacketStats
+        stats = function(_self: Self): Types.PacketStats
             return {
                 bytesSent = reg.bytesSent,
                 bytesReceived = reg.bytesReceived,
@@ -230,7 +239,7 @@ function Packet.define(
         end,
     }
 
-    return table.freeze(handle) :: PacketHandle
+    return table.freeze(handle) :: PacketHandle<T>
 end
 
 return table.freeze(Packet)

package/src/api/Query.luau

@@ -33,23 +33,32 @@ end
 
 -- Public types -----------------------------------------------------------
 
-export type QueryHandle = {
-    handle: (self: QueryHandle, fn: (request: any, player: Player?) -> any) -> Types.Connection,
-    request: (self: QueryHandle, data: any, target: any?) -> any,
-    name: (self: QueryHandle) -> string,
-    stats: (self: QueryHandle) -> Types.PacketStats,
+--[[
+    Server `request(data, target)` returns `Resp?` for a Player target and
+    `{ [Player]: Resp? }` for a multi-target table; Luau doesn't support
+    overloads on table fields, so the type advertises `Resp?` (the common
+    single-target case). Multi-target callers must cast the return.
+]]
+export type QueryHandle<Req, Resp> = {
+    handle: (
+        self: QueryHandle<Req, Resp>,
+        fn: (request: Req, player: Player?) -> Resp?
+    ) -> Types.Connection,
+    request: (self: QueryHandle<Req, Resp>, data: Req, target: any?) -> Resp?,
+    name: (self: QueryHandle<Req, Resp>) -> string,
+    stats: (self: QueryHandle<Req, Resp>) -> Types.PacketStats,
 }
 
 -- Public -----------------------------------------------------------------
 
 local Query = {}
 
-function Query.define(
+function Query.define<Req, Resp>(
     name: string,
-    requestCodec: Types.InternalCodec<any>,
-    responseCodec: Types.InternalCodec<any>,
+    requestCodec: Types.InternalCodec<Req>,
+    responseCodec: Types.InternalCodec<Resp>,
     options: Types.QueryOptions?
-): QueryHandle
+): QueryHandle<Req, Resp>
     local opts = options or ({} :: Types.QueryOptions)
     local timeout = opts.timeout or DEFAULT_TIMEOUT
 
@@ -228,14 +237,16 @@ function Query.define(
         return coroutine.yield()
     end
 
+    type Self = QueryHandle<Req, Resp>
+
     local handle = {
         handle = function(
-            _self: QueryHandle,
-            fn: (request: any, player: Player?) -> any
+            _self: Self,
+            fn: (request: Req, player: Player?) -> Resp?
         ): Types.Connection
             handlerToken += 1
             local myToken = handlerToken
-            activeHandler = fn
+            activeHandler = fn :: any
 
             local conn = { connected = true }
             function conn.disconnect(self): ()
@@ -250,18 +261,18 @@ function Query.define(
             return conn :: Types.Connection
         end,
 
-        request = function(_self: QueryHandle, data: any, target: any?): any
+        request = function(_self: Self, data: Req, target: any?): Resp?
             if IS_SERVER then
                 return requestFromServer(data, target)
             end
             return requestFromClient(data)
         end,
 
-        name = function(_self: QueryHandle): string
+        name = function(_self: Self): string
             return name
         end,
 
-        stats = function(_self: QueryHandle): Types.PacketStats
+        stats = function(_self: Self): Types.PacketStats
             return {
                 bytesSent = reqReg.bytesSent + respReg.bytesSent,
                 bytesReceived = reqReg.bytesReceived + respReg.bytesReceived,
@@ -272,7 +283,7 @@ function Query.define(
         end,
     }
 
-    return table.freeze(handle) :: QueryHandle
+    return table.freeze(handle) :: QueryHandle<Req, Resp>
 end
 
 function Query.pendingCount(): number

package/src/init.luau

@@ -48,6 +48,21 @@ local UDimC = require(script.codec.datatype.UDim)
 local UnknownC = require(script.codec.meta.Unknown)
 local VectorC = require(script.codec.datatype.Vector)
 
+-- Public types (re-exported so users can write `Lync.Packet<MyData>`) ---
+
+export type Codec<T> = Types.Codec<T>
+export type Connection = Types.Connection
+export type Packet<T> = Packet.PacketHandle<T>
+export type Query<Req, Resp> = Query.QueryHandle<Req, Resp>
+export type Group = Group.GroupHandle
+export type Scope = Scope.ScopeHandle
+export type PacketOptions = Types.PacketOptions
+export type QueryOptions = Types.QueryOptions
+export type ConfigureOptions = Types.ConfigureOptions
+export type RateLimitConfig = Types.RateLimitConfig
+export type PacketStats = Types.PacketStats
+export type PlayerStats = Types.PlayerStats
+
 -- Constants --------------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer()