@axpecter/lync 2.0.0 → 2.1.0

package/src/api/Namespace.luau

@@ -1,256 +0,0 @@
---!strict
---!optimize 2
--- Scoped packet/query groups with batch ops and local middleware.
-
-local Middleware = require(script.Parent.Parent.internal.Middleware)
-local Packet = require(script.Parent.Packet)
-local Query = require(script.Parent.Query)
-local Types = require(script.Parent.Parent.Types)
-
-type Connection = Types.Connection
-type PacketConfig<T> = Types.PacketConfig<T>
-type QueryConfig<R, S> = Types.QueryConfig<R, S>
-
--- Constants -----------------------------------------------------------
-
-local MAX_NAMESPACES = 64
-
--- State ---------------------------------------------------------------
-
-local _registered = {} :: { [string]: true }
-local _count = 0
-
--- Private -------------------------------------------------------------
-
-type NamespaceConfig = Types.NamespaceConfig
-
-type NamespaceFields = {
-    _name: string,
-    _packets: { [string]: Packet.Packet },
-    _queries: { [string]: Query.Query },
-    _tracked: { Connection },
-    _removers: { () -> () },
-    packets: { [string]: Packet.Packet },
-    queries: { [string]: Query.Query },
-}
-
-local function prefixName(nsName: string, name: string): string
-    return `{nsName}.{name}`
-end
-
--- Wraps a middleware handler so it only fires for packets in this namespace.
-local function scopedHandler(
-    nsName: string,
-    handler: (data: any, name: string, player: Player?) -> any?
-): (data: any, name: string, player: Player?) -> any?
-    local prefix = nsName .. "."
-    local prefixLen = #prefix
-
-    return function(data: any, name: string, player: Player?): any?
-        if string.sub(name, 1, prefixLen) ~= prefix then
-            return data
-        end
-        return handler(data, name, player)
-    end
-end
-
-local NamespaceImpl = {}
-NamespaceImpl.__index = NamespaceImpl
-
-export type Namespace = typeof(setmetatable({} :: NamespaceFields, NamespaceImpl))
-
--- Listens on every packet in this namespace. Returns a Connection.
-function NamespaceImpl.listenAll(
-    self: Namespace,
-    callback: (
-        name: string,
-        data: any,
-        sender: Player?,
-        timestamp: number?
-    ) -> ()
-): Connection
-    local connections = {} :: { Connection }
-    local prefix = self._name .. "."
-    local prefixLen = #prefix
-
-    for fullName, packet in self._packets do
-        local shortName = string.sub(fullName, prefixLen + 1)
-        local conn = packet:listen(function(data: any, sender: Player?, timestamp: number?): ()
-            callback(shortName, data, sender, timestamp)
-        end)
-        table.insert(connections, conn)
-        table.insert(self._tracked, conn)
-    end
-
-    local bundle: Connection
-    bundle = {
-        connected = true,
-        disconnect = function(self: Connection): ()
-            if not self.connected then
-                return
-            end
-            self.connected = false
-
-            for _, inner in connections do
-                if inner.connected then
-                    inner:disconnect()
-                end
-            end
-        end,
-    }
-
-    return bundle
-end
-
--- Disconnects every listenAll connection. Does not remove scoped middleware.
-function NamespaceImpl.disconnectAll(self: Namespace): ()
-    for _, conn in self._tracked do
-        if conn.connected then
-            conn:disconnect()
-        end
-    end
-    table.clear(self._tracked)
-end
-
--- Registers send middleware scoped to this namespace. Returns a remover.
-function NamespaceImpl.onSend(
-    self: Namespace,
-    handler: (data: any, name: string, player: Player?) -> any?
-): () -> ()
-    local wrapped = scopedHandler(self._name, handler)
-    local remover = Middleware.addSend(wrapped)
-    table.insert(self._removers, remover)
-
-    return function(): ()
-        remover()
-        local idx = table.find(self._removers, remover)
-        if idx then
-            table.remove(self._removers, idx)
-        end
-    end
-end
-
--- Registers receive middleware scoped to this namespace. Returns a remover.
-function NamespaceImpl.onReceive(
-    self: Namespace,
-    handler: (data: any, name: string, player: Player?) -> any?
-): () -> ()
-    local wrapped = scopedHandler(self._name, handler)
-    local remover = Middleware.addReceive(wrapped)
-    table.insert(self._removers, remover)
-
-    return function(): ()
-        remover()
-        local idx = table.find(self._removers, remover)
-        if idx then
-            table.remove(self._removers, idx)
-        end
-    end
-end
-
--- Kills all listeners and removes all scoped middleware. Full cleanup.
-function NamespaceImpl.destroy(self: Namespace): ()
-    self:disconnectAll()
-
-    for _, remover in self._removers do
-        remover()
-    end
-    table.clear(self._removers)
-end
-
--- Returns every packet name(without prefix) in this namespace.
-function NamespaceImpl.packetNames(self: Namespace): { string }
-    local result = {} :: { string }
-    local prefix = self._name .. "."
-    local prefixLen = #prefix
-
-    for fullName in self._packets do
-        table.insert(result, string.sub(fullName, prefixLen + 1))
-    end
-
-    table.sort(result)
-    return result
-end
-
--- Returns every query name(without prefix) in this namespace.
-function NamespaceImpl.queryNames(self: Namespace): { string }
-    local result = {} :: { string }
-    local prefix = self._name .. "."
-    local prefixLen = #prefix
-
-    for fullName in self._queries do
-        table.insert(result, string.sub(fullName, prefixLen + 1))
-    end
-
-    table.sort(result)
-    return result
-end
-
-table.freeze(NamespaceImpl)
-
--- Public --------------------------------------------------------------
-
-local NamespaceModule = {}
-
--- Defines a namespace. Names are auto-prefixed to prevent collisions.
-function NamespaceModule.define(name: string, config: NamespaceConfig): Namespace
-    if #name == 0 then
-        error("[Lync] Namespace name must not be empty")
-    end
-    if _registered[name] then
-        error(`[Lync] Duplicate namespace: "{name}"`)
-    end
-    if _count >= MAX_NAMESPACES then
-        error(`[Lync] Namespace limit reached: {MAX_NAMESPACES}`)
-    end
-
-    _count += 1
-    _registered[name] = true
-
-    local packets = {} :: { [string]: Packet.Packet }
-    local queries = {} :: { [string]: Query.Query }
-    local packetsByShort = {} :: { [string]: Packet.Packet }
-    local queriesByShort = {} :: { [string]: Query.Query }
-
-    if config.packets then
-        for shortName, packetConfig in config.packets do
-            local fullName = prefixName(name, shortName)
-            local packet = Packet.define(fullName, packetConfig)
-            packets[fullName] = packet
-            packetsByShort[shortName] = packet
-        end
-    end
-
-    if config.queries then
-        for shortName, queryConfig in config.queries do
-            local fullName = prefixName(name, shortName)
-            local query = Query.define(fullName, queryConfig)
-            queries[fullName] = query
-            queriesByShort[shortName] = query
-        end
-    end
-
-    local nsFields: NamespaceFields = {
-        _name = name,
-        _packets = packets,
-        _queries = queries,
-        _tracked = {} :: { Connection },
-        _removers = {} :: { () -> () },
-        packets = table.freeze(packetsByShort),
-        queries = table.freeze(queriesByShort),
-    }
-
-    -- Inject dynamic short-name accessors (ns.Hit, ns.Stats, etc.)
-    -- These bypass the typed fields; consumers should prefer ns.packets.X / ns.queries.X.
-    local raw = nsFields :: any
-    for shortName, packet in packetsByShort do
-        raw[shortName] = packet
-    end
-    for shortName, query in queriesByShort do
-        raw[shortName] = query
-    end
-
-    return setmetatable(nsFields, NamespaceImpl)
-end
-
-return table.freeze(NamespaceModule)

package/src/codec/meta/Quantized.luau

@@ -1,174 +0,0 @@
---!strict
---!native
--- Fixed-point compression. Maps float ranges to integer ranges.
-
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Types = require(script.Parent.Parent.Parent.Types)
-
-type ChannelState = Types.ChannelState
-type Codec<T> = Types.Codec<T>
-
-local alloc = Channel.alloc
-
--- Constants -----------------------------------------------------------
-
-local clamp = math.clamp
-local round = math.round
-local ceil = math.ceil
-local min = math.min
-local max = math.max
-
-local U32_MAX = 4294967295
-
--- Private -------------------------------------------------------------
-
-local function selectIO(bytes: number): ((b: buffer, offset: number, v: number) -> (), (
-    b: buffer,
-    offset: number
-) -> number)
-    if bytes == 1 then
-        return buffer.writeu8, buffer.readu8
-    end
-    if bytes == 2 then
-        return buffer.writeu16, buffer.readu16
-    end
-    return buffer.writeu32, buffer.readu32
-end
-
-local function selectWidth(maxInt: number): number
-    if maxInt <= 255 then
-        return 1
-    end
-    if maxInt <= 65535 then
-        return 2
-    end
-    return 4
-end
-
--- Public --------------------------------------------------------------
-
-local Quantized = {}
-
--- Shared validation and precomputation for both float and vec3 quantizers.
-local function setup(
-    minVal: number,
-    maxVal: number,
-    precision: number
-): (number?, number?, number?, any?, any?, number?, number?)
-    if minVal > maxVal then
-        error(`[Lync] Quantized min > max: {minVal} > {maxVal}`)
-    end
-    if precision <= 0 then
-        error(`[Lync] Quantized precision must be positive: {precision}`)
-    end
-
-    local delta = maxVal - minVal
-    if delta == 0 then
-        return nil
-    end
-
-    local maxInt = min(U32_MAX, max(1, ceil(delta / precision)))
-    local bytes = selectWidth(maxInt)
-    local wfn, rfn = selectIO(bytes)
-    local invDelta = 1 / delta
-    local invMaxInt = delta / maxInt
-
-    return delta, maxInt, bytes, wfn, rfn, invDelta, invMaxInt
-end
-
-function Quantized.float(minVal: number, maxVal: number, precision: number): Codec<number>
-    local delta, maxInt, bytes, wfn, rfn, invDelta, invMaxInt = setup(minVal, maxVal, precision)
-    if not delta then
-        return table.freeze({
-            _size = 0,
-            _directWrite = function(_b: buffer, _offset: number, _value: number): () end,
-            _directRead = function(_b: buffer, _offset: number): number
-                return minVal
-            end,
-            write = function(_ch: ChannelState, _value: number): () end,
-            read = function(_src: buffer, _pos: number, _refs: { Instance }?): (number, number)
-                return minVal, 0
-            end,
-        })
-    end
-
-    return table.freeze({
-        _size = bytes,
-        _directWrite = function(b: buffer, offset: number, value: number): ()
-            wfn(b, offset, round(clamp((value - minVal) * invDelta, 0, 1) * maxInt))
-        end,
-        _directRead = function(b: buffer, offset: number): number
-            return rfn(b, offset) * invMaxInt + minVal
-        end,
-        write = function(ch: ChannelState, value: number): ()
-            local c = ch.cursor
-            if c + bytes > ch.size then
-                alloc(ch, bytes)
-            end
-            wfn(ch.buff, c, round(clamp((value - minVal) * invDelta, 0, 1) * maxInt))
-            ch.cursor = c + bytes
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
-            return rfn(src, pos) * invMaxInt + minVal, bytes
-        end,
-    })
-end
-
-function Quantized.vec3(minVal: number, maxVal: number, precision: number): Codec<Vector3>
-    local delta, maxInt, compBytes, wfn, rfn, invDelta, invMaxInt = setup(minVal, maxVal, precision)
-    if not delta then
-        local val = Vector3.new(minVal, minVal, minVal)
-        return table.freeze({
-            _size = 0,
-            _directWrite = function(_b: buffer, _offset: number, _value: Vector3): () end,
-            _directRead = function(_b: buffer, _offset: number): Vector3
-                return val
-            end,
-            write = function(_ch: ChannelState, _value: Vector3): () end,
-            read = function(_src: buffer, _pos: number, _refs: { Instance }?): (Vector3, number)
-                return val, 0
-            end,
-        })
-    end
-
-    local totalBytes = compBytes * 3
-    local stride = compBytes
-    local stride2 = compBytes * 2
-
-    return table.freeze({
-        _size = totalBytes,
-        _directWrite = function(b: buffer, offset: number, value: Vector3): ()
-            wfn(b, offset, round(clamp((value.X - minVal) * invDelta, 0, 1) * maxInt))
-            wfn(b, offset + stride, round(clamp((value.Y - minVal) * invDelta, 0, 1) * maxInt))
-            wfn(b, offset + stride2, round(clamp((value.Z - minVal) * invDelta, 0, 1) * maxInt))
-        end,
-        _directRead = function(b: buffer, offset: number): Vector3
-            return Vector3.new(
-                rfn(b, offset) * invMaxInt + minVal,
-                rfn(b, offset + stride) * invMaxInt + minVal,
-                rfn(b, offset + stride2) * invMaxInt + minVal
-            )
-        end,
-        write = function(ch: ChannelState, value: Vector3): ()
-            local c = ch.cursor
-            if c + totalBytes > ch.size then
-                alloc(ch, totalBytes)
-            end
-            local b = ch.buff
-            wfn(b, c, round(clamp((value.X - minVal) * invDelta, 0, 1) * maxInt))
-            wfn(b, c + stride, round(clamp((value.Y - minVal) * invDelta, 0, 1) * maxInt))
-            wfn(b, c + stride2, round(clamp((value.Z - minVal) * invDelta, 0, 1) * maxInt))
-            ch.cursor = c + totalBytes
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
-            return Vector3.new(
-                rfn(src, pos) * invMaxInt + minVal,
-                rfn(src, pos + stride) * invMaxInt + minVal,
-                rfn(src, pos + stride2) * invMaxInt + minVal
-            ),
-                totalBytes
-        end,
-    })
-end
-
-return table.freeze(Quantized)