@axpecter/lync 2.3.3 → 3.0.0

package/src/api/Query.luau

@@ -1,338 +0,0 @@
---!strict
---!optimize 2
--- Query definition: handle, request with correlation IDs and timeout.
-
-local Players = game:GetService("Players")
-local RunService = game:GetService("RunService")
-
-local Channel = require(script.Parent.Parent.internal.Channel)
-local Log = require(script.Parent.Parent.util.Log)
-local Player = require(script.Parent.Parent.util.Player)
-local Registry = require(script.Parent.Parent.internal.Registry)
-local Transport = require(script.Parent.Parent.internal.Transport)
-local Types = require(script.Parent.Parent.Types)
-
--- Constants --------------------------------------------------------------
-
-local IS_SERVER = RunService:IsServer()
-local DEFAULT_TIMEOUT = 5
-
-local EMPTY_OPTIONS: Types.QueryOptions = table.freeze({})
-
--- State ------------------------------------------------------------------
-
-local _nextCorrId = 0
--- Correlation -> waiting thread / completion closure. Cleared on resolve or timeout.
-local _pending: { [number]: thread } = {}
-local _pendingGather: { [number]: (any) -> () } = {}
-
--- Private ----------------------------------------------------------------
-
-local isPlayer = Player.is
-
-local function nextCorr(): number
-    _nextCorrId += 1
-    return _nextCorrId
-end
-
-local function writeQueryTracked(
-    ch: Types.ChannelState,
-    reg: Types.Registration,
-    corrId: number,
-    codec: Types.InternalCodec<any>?,
-    data: any
-): ()
-    if Channel.statsEnabled() then
-        local before = ch.cursor
-        Channel.writeQuery(ch, reg.id, corrId, codec, data, reg.name)
-        reg.bytesSent += ch.cursor - before
-    else
-        Channel.writeQuery(ch, reg.id, corrId, codec, data, reg.name)
-    end
-end
-
-local function collectTargets(target: any): { Player }
-    local targets: { Player } = {}
-    if typeof(target) ~= "table" then
-        return targets
-    end
-
-    local kind = target._lyncKind
-    if kind == "all" then
-        for _, p in Players:GetPlayers() do
-            table.insert(targets, p)
-        end
-    elseif kind == "group" then
-        for p in target._members do
-            table.insert(targets, p)
-        end
-    else
-        for _, p in target do
-            if isPlayer(p) then
-                table.insert(targets, p :: Player)
-            end
-        end
-    end
-    return targets
-end
-
--- Public types -----------------------------------------------------------
-
---[[
-    Server `request(data, target)` returns `Resp?` for a Player target and
-    `{ [Player]: Resp? }` for a multi-target table; Luau lacks overloads on
-    table fields, so the type advertises `Resp?` and multi-target callers cast.
-]]
-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<Req, Resp>(
-    name: string,
-    requestCodec: Types.InternalCodec<Req>,
-    responseCodec: Types.InternalCodec<Resp>,
-    options: Types.QueryOptions?
-): QueryHandle<Req, Resp>
-    local opts = options or EMPTY_OPTIONS
-    local timeout = opts.timeout or DEFAULT_TIMEOUT
-
-    local reqOpenFn = Channel.resolveOpenFn(Channel.TS_NONE, name)
-    -- Embedded "\0resp" suffix stays uniquely paired with the request reg.
-    local respName = `{name}\0resp`
-    local respOpenFn = Channel.resolveOpenFn(Channel.TS_NONE, respName)
-
-    local reqReg = Registry.register({
-        name = name,
-        kind = Registry.KIND_REQUEST,
-        codec = requestCodec,
-        isUnreliable = false,
-        partner = nil,
-        needsGate = IS_SERVER,
-        headerSize = 1,
-        timestampMode = Channel.TS_NONE,
-        openFn = reqOpenFn,
-        rateLimit = opts.rateLimit or { maxPerSecond = 30 },
-        validate = opts.validate,
-        maxPayloadBytes = nil,
-    })
-
-    local respReg = Registry.register({
-        name = respName,
-        kind = Registry.KIND_RESPONSE,
-        codec = responseCodec,
-        isUnreliable = false,
-        partner = reqReg.id,
-        needsGate = false,
-        headerSize = 1,
-        timestampMode = Channel.TS_NONE,
-        openFn = respOpenFn,
-        rateLimit = nil,
-        validate = nil,
-        maxPayloadBytes = nil,
-    })
-
-    reqReg.partner = respReg.id
-
-    -- Single active handler; replacing it disconnects the prior one via handlerToken.
-    local activeHandler: ((any, Player?) -> any)? = nil
-    local handlerToken = 0
-
-    respReg.signal:connect(function(value: any, _sender: Player?, corrId: number)
-        local single = _pending[corrId]
-        if single then
-            _pending[corrId] = nil
-            task.spawn(single, value)
-            return
-        end
-        local gather = _pendingGather[corrId]
-        if gather then
-            _pendingGather[corrId] = nil
-            gather(value)
-        end
-    end)
-
-    reqReg.signal:connect(function(value: any, sender: Player?, corrId: number)
-        local handler = activeHandler
-        if not handler then
-            return
-        end
-
-        local ok, response = pcall(handler, value, sender)
-        if not ok then
-            Log.warn(`query "{name}" handler errored: {response}`)
-        end
-        -- pcall failure path returns nil response (writeQuery encodes a nil-MSB header).
-        local payloadCodec = if ok then responseCodec else nil
-        local payloadData = if ok then response else nil
-
-        local ch: Types.ChannelState? = if IS_SERVER
-            then (if sender then Transport.server().getChannel(sender, false) else nil)
-            else Transport.client().getChannel(false)
-        if ch then
-            writeQueryTracked(ch, respReg, corrId, payloadCodec, payloadData)
-        end
-    end)
-
-    -- Resolve the waiting thread with nil after `timeout` seconds.
-    local function scheduleSingleTimeout(corrId: number, running: thread): ()
-        task.delay(timeout, function()
-            if _pending[corrId] == running then
-                _pending[corrId] = nil
-                task.spawn(running, nil)
-            end
-        end)
-    end
-
-    -- Issue a single-target query on `ch` and yield until reply or timeout.
-    local function requestOnChannel(ch: Types.ChannelState, data: any): any
-        local corrId = nextCorr()
-        writeQueryTracked(ch, reqReg, corrId, requestCodec, data)
-
-        local running = coroutine.running()
-        _pending[corrId] = running
-        scheduleSingleTimeout(corrId, running)
-        return coroutine.yield()
-    end
-
-    local function requestMulti(targets: { Player }, data: any): { [Player]: any }
-        local targetCount = #targets
-        if targetCount == 0 then
-            return {}
-        end
-
-        local results: { [Player]: any } = {}
-        local remaining = targetCount
-        local running = coroutine.running()
-        local resolved = false
-        local corrIds = table.create(targetCount)
-
-        --[[
-            On timeout, surface the partial result table AND evict every
-            still-pending closure. Without eviction each unanswered closure
-            keeps `results`/`remaining`/`resolveOnce` alive: a slow leak.
-        ]]
-        local function resolveOnce(): ()
-            if resolved then
-                return
-            end
-            resolved = true
-            for i = 1, targetCount do
-                _pendingGather[corrIds[i]] = nil
-            end
-            task.spawn(running, results)
-        end
-
-        local Server = Transport.server()
-        for i, p in targets do
-            local pCorr = nextCorr()
-            corrIds[i] = pCorr
-            local ch = Server.getChannel(p, false)
-            writeQueryTracked(ch, reqReg, pCorr, requestCodec, data)
-
-            local pRef = p
-            _pendingGather[pCorr] = function(response: any)
-                results[pRef] = response
-                remaining -= 1
-                if remaining == 0 then
-                    resolveOnce()
-                end
-            end
-        end
-
-        task.delay(timeout, resolveOnce)
-        return coroutine.yield()
-    end
-
-    local function requestFromServer(data: any, target: any): any
-        if target == nil then
-            Log.error(`"{name}" server request requires a target`)
-        end
-        if isPlayer(target) then
-            return requestOnChannel(Transport.server().getChannel(target :: Player, false), data)
-        end
-        return requestMulti(collectTargets(target), data)
-    end
-
-    local function requestFromClient(data: any): any
-        return requestOnChannel(Transport.client().getChannel(false), data)
-    end
-
-    type Self = QueryHandle<Req, Resp>
-
-    local handle = {
-        --[[
-            Replace the active handler. The returned Connection only clears
-            the active slot if no later :handle has overwritten it: token
-            comparison guards against a stale disconnect wiping a fresh handler.
-        ]]
-        handle = function(
-            _self: Self,
-            fn: (request: Req, player: Player?) -> Resp?
-        ): Types.Connection
-            handlerToken += 1
-            local myToken = handlerToken
-            activeHandler = fn :: any
-
-            local conn: Types.Connection
-            conn = {
-                connected = true,
-                disconnect = function(self): ()
-                    if not self.connected then
-                        return
-                    end
-                    self.connected = false
-                    if handlerToken == myToken then
-                        activeHandler = nil
-                    end
-                end,
-            }
-            return conn
-        end,
-
-        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: Self): string
-            return name
-        end,
-
-        stats = function(_self: Self): Types.PacketStats
-            return {
-                bytesSent = reqReg.bytesSent + respReg.bytesSent,
-                bytesReceived = reqReg.bytesReceived + respReg.bytesReceived,
-                fires = reqReg.fires + respReg.fires,
-                recvFires = reqReg.recvFires + respReg.recvFires,
-                drops = reqReg.drops + respReg.drops,
-            }
-        end,
-    }
-
-    return table.freeze(handle) :: QueryHandle<Req, Resp>
-end
-
-function Query.pendingCount(): number
-    local count = 0
-    for _ in _pending do
-        count += 1
-    end
-    for _ in _pendingGather do
-        count += 1
-    end
-    return count
-end
-
-return table.freeze(Query)

package/src/api/Scope.luau

@@ -1,90 +0,0 @@
---!strict
---!optimize 2
--- Batched connection lifecycle for Lync, RBXScriptConnection, and disconnect()-style objects.
-
-local Types = require(script.Parent.Parent.Types)
-
--- Public types -----------------------------------------------------------
-
-export type ScopeHandle = {
-    on: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
-    once: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
-    add: (self: ScopeHandle, connection: any) -> (),
-    size: (self: ScopeHandle) -> number,
-    destroy: (self: ScopeHandle) -> (),
-}
-
-type Scope = ScopeHandle & { _connections: { any }, _count: number }
-
--- Private ----------------------------------------------------------------
-
-local function pushConnection(self: Scope, conn: any): ()
-    local idx = self._count + 1
-    self._count = idx
-    self._connections[idx] = conn
-end
-
--- Routes :on / :once through `methodName` so both call sites share insert + size bookkeeping.
-local function attach(
-    self: Scope,
-    source: any,
-    fn: (...any) -> (),
-    methodName: string
-): Types.Connection
-    local conn = source[methodName](source, fn)
-    pushConnection(self, conn)
-    return conn
-end
-
--- Public -----------------------------------------------------------------
-
-local ScopeMeta = {}
-ScopeMeta.__index = ScopeMeta
-
-function ScopeMeta.on(self: Scope, source: any, fn: (...any) -> ()): Types.Connection
-    return attach(self, source, fn, "on")
-end
-
-function ScopeMeta.once(self: Scope, source: any, fn: (...any) -> ()): Types.Connection
-    return attach(self, source, fn, "once")
-end
-
-ScopeMeta.add = pushConnection
-
-function ScopeMeta.size(self: Scope): number
-    return self._count
-end
-
---[[
-    Disconnect every tracked source. The shape sniff handles three kinds:
-    Roblox RBXScriptConnection (:Disconnect), Lync Connection (:disconnect),
-    and tables exposing either capitalization.
-]]
-function ScopeMeta.destroy(self: Scope): ()
-    local conns = self._connections
-    local count = self._count
-    for i = 1, count do
-        local conn = conns[i]
-        conns[i] = nil
-        if typeof(conn) == "RBXScriptConnection" then
-            (conn :: RBXScriptConnection):Disconnect()
-        elseif typeof(conn) == "table" then
-            if conn.disconnect then
-                conn:disconnect()
-            elseif conn.Disconnect then
-                conn:Disconnect()
-            end
-        end
-    end
-    self._count = 0
-end
-
-table.freeze(ScopeMeta)
-
-local ScopeModule = {}
-
-function ScopeModule.create(): ScopeHandle
-    return (setmetatable({ _connections = {}, _count = 0 }, ScopeMeta) :: any) :: ScopeHandle
-end
-
-return table.freeze(ScopeModule)

package/src/api/Signal.luau

@@ -1,193 +0,0 @@
---!strict
---!optimize 2
--- O(1) disconnect signal with thread reuse and reentrancy-safe fire.
-
-local Types = require(script.Parent.Parent.Types)
-
--- Constants --------------------------------------------------------------
-
-local STATE_DISCONNECTED = 0
-local STATE_CONNECTED = 1
-local STATE_ONCE = 2
-
--- State ------------------------------------------------------------------
-
--- Single recyclable thread for async dispatch; saves coroutine.create per fire.
-local _freeThread: thread? = nil
-
--- Private ----------------------------------------------------------------
-
--- pcall wrapper: a handler error must not consume the recycled thread, otherwise
--- every subsequent fire pays a coroutine.create until process restart.
-local function passer(fn: (...any) -> (), ...): ()
-    local thread = _freeThread
-    _freeThread = nil
-    local ok, err = pcall(fn, ...)
-    _freeThread = thread
-    if not ok then
-        task.spawn(error, err)
-    end
-end
-
-local function yielder(): ()
-    while true do
-        passer(coroutine.yield())
-    end
-end
-
-local function spawnCallback(fn: (...any) -> (), ...: any): ()
-    if not _freeThread then
-        _freeThread = coroutine.create(yielder)
-        coroutine.resume(_freeThread :: thread)
-    end
-    task.spawn(_freeThread :: thread, fn, ...)
-end
-
-type Entry = {
-    fn: (...any) -> (),
-    _state: number,
-    connected: boolean,
-    _signal: SignalFields,
-    _index: number,
-}
-
-type SignalFields = {
-    _entries: { Entry },
-    _count: number,
-}
-
-local EntryImpl = {}
-EntryImpl.__index = EntryImpl
-
--- Swap-with-last for O(1) disconnect; the moved entry's _index is patched too.
-local function disconnectEntry(entry: Entry): ()
-    if entry._state == STATE_DISCONNECTED then
-        return
-    end
-
-    entry._state = STATE_DISCONNECTED
-    entry.connected = false
-
-    local signal = entry._signal
-    local entries = signal._entries
-    local idx = entry._index
-    local last = signal._count
-
-    if idx < last then
-        local moved = entries[last]
-        entries[idx] = moved
-        moved._index = idx
-    end
-    entries[last] = nil
-    signal._count = last - 1
-end
-
-EntryImpl.disconnect = disconnectEntry
-table.freeze(EntryImpl)
-
--- Auto-disconnects ONCE entries before invoking; chooses sync vs spawned thread.
-local function invokeEntry(entry: Entry, sync: boolean, ...: any): ()
-    local state = entry._state
-    if state == STATE_DISCONNECTED then
-        return
-    end
-    if state == STATE_ONCE then
-        disconnectEntry(entry)
-    end
-    if sync then
-        entry.fn(...)
-    else
-        spawnCallback(entry.fn, ...)
-    end
-end
-
-local SignalImpl = {}
-SignalImpl.__index = SignalImpl
-
-local function newEntry(self: SignalFields, callback: (...any) -> (), state: number): Entry
-    local idx = self._count + 1
-    self._count = idx
-
-    local entry: Entry = setmetatable({
-        fn = callback,
-        _state = state,
-        connected = true,
-        _signal = self,
-        _index = idx,
-    }, EntryImpl) :: any
-
-    self._entries[idx] = entry
-    return entry
-end
-
-function SignalImpl.connect(self: SignalFields, callback: (...any) -> ()): Types.Connection
-    return newEntry(self, callback, STATE_CONNECTED) :: any
-end
-
-function SignalImpl.once(self: SignalFields, callback: (...any) -> ()): Types.Connection
-    return newEntry(self, callback, STATE_ONCE) :: any
-end
-
-function SignalImpl.wait(self: SignalFields): ...any
-    local running = coroutine.running()
-    local conn: Types.Connection
-    conn = SignalImpl.connect(self, function(...: any)
-        conn:disconnect()
-        task.spawn(running, ...)
-    end)
-    return coroutine.yield()
-end
-
-local function dispatch(self: SignalFields, sync: boolean, ...: any): ()
-    local count = self._count
-    if count == 0 then
-        return
-    end
-
-    local entries = self._entries
-
-    -- Single-listener fast path skips the snapshot allocation.
-    if count == 1 then
-        invokeEntry(entries[1], sync, ...)
-        return
-    end
-
-    --[[
-        Re-entrancy: a handler may disconnect or add others mid-fire.
-        Snapshot the entry list so the iteration view is stable.
-    ]]
-    local snapshot = table.create(count)
-    table.move(entries, 1, count, 1, snapshot)
-
-    for i = 1, count do
-        invokeEntry(snapshot[i], sync, ...)
-    end
-end
-
-function SignalImpl.fire(self: SignalFields, ...: any): ()
-    dispatch(self, false, ...)
-end
-
-function SignalImpl.fireSync(self: SignalFields, ...: any): ()
-    dispatch(self, true, ...)
-end
-
-function SignalImpl.count(self: SignalFields): number
-    return self._count
-end
-
-function SignalImpl.hasListeners(self: SignalFields): boolean
-    return self._count > 0
-end
-
-table.freeze(SignalImpl)
-
--- Public -----------------------------------------------------------------
-
-local SignalModule = {}
-
-function SignalModule.create(): Types.SignalLike
-    return (setmetatable({ _entries = {}, _count = 0 }, SignalImpl) :: any) :: Types.SignalLike
-end
-
-return table.freeze(SignalModule)