@axpecter/lync 1.4.1 → 1.5.0

package/src/api/Scope.luau

@@ -2,12 +2,23 @@
 --!optimize 2
 -- Batched connection lifecycle management.
 
--- Private ------------------------------------------------------------
+local Types = require(script.Parent.Parent.Types)
+
+type Connection = Types.Connection
+
+-- Private -------------------------------------------------------------
+
+type ScopeFields = {
+    _entries: { any }, -- Connection | RBXScriptConnection
+    _count: number,
+}
 
 local ScopeImpl = {}
 ScopeImpl.__index = ScopeImpl
 
-function ScopeImpl.add (self: any, conn: any): ()
+export type Scope = typeof(setmetatable({} :: ScopeFields, ScopeImpl))
+
+function ScopeImpl.add(self: Scope, conn: any): ()
     if not conn then
         return
     end
@@ -18,31 +29,31 @@ function ScopeImpl.add (self: any, conn: any): ()
     entries[count] = conn
 end
 
-function ScopeImpl.listen (self: any, source: any, callback: (...any) -> ()): ()
-    local conn = source:listen (callback)
+function ScopeImpl.listen(self: Scope, source: any, callback: (...any) -> ()): ()
+    local conn = source:listen(callback)
     local entries = self._entries
     local count = self._count + 1
     self._count = count
     entries[count] = conn
 end
 
-function ScopeImpl.once (self: any, source: any, callback: (...any) -> ()): ()
-    local conn = source:once (callback)
+function ScopeImpl.once(self: Scope, source: any, callback: (...any) -> ()): ()
+    local conn = source:once(callback)
     local entries = self._entries
     local count = self._count + 1
     self._count = count
     entries[count] = conn
 end
 
-function ScopeImpl.listenAll (self: any, namespace: any, callback: (...any) -> ()): ()
-    local conn = namespace:listenAll (callback)
+function ScopeImpl.listenAll(self: Scope, namespace: any, callback: (...any) -> ()): ()
+    local conn = namespace:listenAll(callback)
     local entries = self._entries
     local count = self._count + 1
     self._count = count
     entries[count] = conn
 end
 
-function ScopeImpl.destroy (self: any): ()
+function ScopeImpl.destroy(self: Scope): ()
     local entries = self._entries
     local count = self._count
 
@@ -50,24 +61,27 @@ function ScopeImpl.destroy (self: any): ()
         local conn = entries[i]
         entries[i] = nil
 
-        if typeof (conn) == "RBXScriptConnection" then
-            conn:Disconnect ()
+        if typeof(conn) == "RBXScriptConnection" then
+            conn:Disconnect()
         elseif conn.disconnect then
-            conn:disconnect ()
+            conn:disconnect()
         end
     end
 
     self._count = 0
 end
 
-table.freeze (ScopeImpl)
+table.freeze(ScopeImpl)
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
-local Scope = {}
+local ScopeModule = {}
 
-function Scope.create (): any
-    return setmetatable ({ _entries = {}, _count = 0 }, ScopeImpl)
+function ScopeModule.create(): Scope
+    return setmetatable({
+        _entries = {},
+        _count = 0,
+    }, ScopeImpl)
 end
 
-return table.freeze (Scope)
+return table.freeze(ScopeModule)

package/src/api/Signal.luau

@@ -2,48 +2,64 @@
 --!optimize 2
 -- O(1) disconnect listener system with thread reuse.
 
-local Types = require (script.Parent.Parent.Types)
+local Types = require(script.Parent.Parent.Types)
 
 type Connection = Types.Connection
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local STATE_DISCONNECTED = 0
 local STATE_CONNECTED = 1
 local STATE_ONCE = 2
 
--- Private ------------------------------------------------------------
+-- Private -------------------------------------------------------------
 
 local _freeThread: thread? = nil
 
-local function passer (fn: (...any) -> (), ...: any): ()
+local function passer(fn: (...any) -> (), ...: any): ()
     local acquired = _freeThread
     _freeThread = nil
-    fn (...)
+    fn(...)
     _freeThread = acquired
 end
 
-local function yielder (): ()
+local function yielder(): ()
     while true do
-        passer (coroutine.yield ())
+        passer(coroutine.yield())
     end
 end
 
-local function spawn (fn: (...any) -> (), ...: any): ()
+local function spawn(fn: (...any) -> (), ...: any): ()
     if not _freeThread then
-        _freeThread = coroutine.create (yielder)
-        coroutine.resume (_freeThread :: thread)
+        _freeThread = coroutine.create(yielder)
+        coroutine.resume(_freeThread :: thread)
     end
-    task.spawn (_freeThread :: thread, fn, ...)
+    task.spawn(_freeThread :: thread, fn, ...)
 end
 
--- Entry doubles as the Connection handle: 1 alloc per listener instead of 2.
--- self: any — metatable typing via typeof(setmetatable) is not practical here
--- because Entry and Signal reference each other circularly.
+-- Mutually recursive field types for Entry and Signal.
+-- Entry._signal references the signal's fields; Signal._entries holds entries.
+-- Luau resolves the cycle at type-check time.
+type EntryFields = {
+    fn: (...any) -> (),
+    _state: number,
+    connected: boolean,
+    _signal: SignalFields,
+    _index: number,
+}
+
+type SignalFields = {
+    _entries: { EntryFields },
+    _count: number,
+    _snapshot: { EntryFields },
+}
+
 local EntryImpl = {}
 EntryImpl.__index = EntryImpl
 
-function EntryImpl.disconnect (self: any): ()
+type EntrySelf = typeof(setmetatable({} :: EntryFields, EntryImpl))
+
+function EntryImpl.disconnect(self: EntrySelf): ()
     if self._state == STATE_DISCONNECTED then
         return
     end
@@ -65,51 +81,53 @@ function EntryImpl.disconnect (self: any): ()
         last._index = index
     end
 
-    entries[count] = nil
+    entries[count] = nil :: any
     self._signal._count = count - 1
 end
 
 local SignalImpl = {}
 SignalImpl.__index = SignalImpl
 
-local function addEntry (self: any, callback: (...any) -> (), isOnce: boolean): Connection
+export type Signal = typeof(setmetatable({} :: SignalFields, SignalImpl))
+
+local function addEntry(self: Signal, callback: (...any) -> (), isOnce: boolean): Connection
     local count = self._count + 1
     self._count = count
 
-    local entry = setmetatable ({
+    local entry = setmetatable({
         fn = callback,
         _state = if isOnce then STATE_ONCE else STATE_CONNECTED,
         connected = true,
-        _signal = self,
+        _signal = self :: any,
         _index = count,
     }, EntryImpl)
 
-    self._entries[count] = entry
+    self._entries[count] = entry :: any
     return entry :: any
 end
 
-function SignalImpl.connect (self: any, callback: (...any) -> ()): Connection
-    return addEntry (self, callback, false)
+function SignalImpl.connect(self: Signal, callback: (...any) -> ()): Connection
+    return addEntry(self, callback, false)
 end
 
-function SignalImpl.once (self: any, callback: (...any) -> ()): Connection
-    return addEntry (self, callback, true)
+function SignalImpl.once(self: Signal, callback: (...any) -> ()): Connection
+    return addEntry(self, callback, true)
 end
 
-function SignalImpl.wait (self: any): ...any
-    local thread = coroutine.running ()
+function SignalImpl.wait(self: Signal): ...any
+    local thread = coroutine.running()
     local entry: any
 
-    entry = addEntry (self, function (...: any): ()
-        entry:disconnect ()
-        task.spawn (thread, ...)
+    entry = addEntry(self, function(...: any): ()
+        entry:disconnect()
+        task.spawn(thread, ...)
     end, true)
 
-    return coroutine.yield ()
+    return coroutine.yield()
 end
 
--- Dispatches to all listeners via task.spawn (safe for yielding handlers).
-function SignalImpl.fire (self: any, ...: any): ()
+-- Dispatches to all listeners via task.spawn(safe for yielding handlers).
+function SignalImpl.fire(self: Signal, ...: any): ()
     local entries = self._entries
     local count = self._count
     if count == 0 then
@@ -123,41 +141,41 @@ function SignalImpl.fire (self: any, ...: any): ()
             return
         end
 
-        spawn (entry.fn, ...)
+        spawn(entry.fn, ...)
 
         if state == STATE_ONCE then
-            entry:disconnect ()
+            (entry :: any):disconnect()
         end
         return
     end
 
     local snapshot = self._snapshot
-    table.move (entries, 1, count, 1, snapshot)
+    table.move(entries, 1, count, 1, snapshot)
 
     local tail = count + 1
     if snapshot[tail] ~= nil then
-        snapshot[tail] = nil
+        snapshot[tail] = nil :: any
     end
 
     for i = 1, count do
         local entry = snapshot[i]
-        snapshot[i] = nil
+        snapshot[i] = nil :: any
 
         local state = entry._state
         if state == STATE_DISCONNECTED then
             continue
         end
 
-        spawn (entry.fn, ...)
+        spawn(entry.fn, ...)
 
         if state == STATE_ONCE then
-            entry:disconnect ()
+            (entry :: any):disconnect()
         end
     end
 end
 
 -- Synchronous dispatch. Only safe when all listeners are non-yielding.
-function SignalImpl.fireSync (self: any, ...: any): ()
+function SignalImpl.fireSync(self: Signal, ...: any): ()
     local entries = self._entries
     local count = self._count
     if count == 0 then
@@ -171,60 +189,64 @@ function SignalImpl.fireSync (self: any, ...: any): ()
             return
         end
 
-        entry.fn (...)
+        entry.fn(...)
 
         if state == STATE_ONCE then
-            entry:disconnect ()
+            (entry :: any):disconnect()
         end
         return
     end
 
     local snapshot = self._snapshot
-    table.move (entries, 1, count, 1, snapshot)
+    table.move(entries, 1, count, 1, snapshot)
 
     local tail = count + 1
     if snapshot[tail] ~= nil then
-        snapshot[tail] = nil
+        snapshot[tail] = nil :: any
     end
 
     for i = 1, count do
         local entry = snapshot[i]
-        snapshot[i] = nil
+        snapshot[i] = nil :: any
 
         local state = entry._state
         if state == STATE_DISCONNECTED then
             continue
         end
 
-        entry.fn (...)
+        entry.fn(...)
 
         if state == STATE_ONCE then
-            entry:disconnect ()
+            (entry :: any):disconnect()
         end
     end
 end
 
-function SignalImpl.disconnectAll (self: any): ()
+function SignalImpl.disconnectAll(self: Signal): ()
     local entries = self._entries
 
     for i = 1, self._count do
         entries[i]._state = STATE_DISCONNECTED
         entries[i].connected = false
-        entries[i] = nil
+        entries[i] = nil :: any
     end
 
     self._count = 0
 end
 
-table.freeze (EntryImpl)
-table.freeze (SignalImpl)
+table.freeze(EntryImpl)
+table.freeze(SignalImpl)
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
-local Signal = {}
+local SignalModule = {}
 
-function Signal.create (): any
-    return setmetatable ({ _entries = {}, _count = 0, _snapshot = {} }, SignalImpl)
+function SignalModule.create(): Signal
+    return setmetatable({
+        _entries = {} :: { EntryFields },
+        _count = 0,
+        _snapshot = {} :: { EntryFields },
+    }, SignalImpl)
 end
 
-return table.freeze (Signal)
+return table.freeze(SignalModule)

package/src/codec/Base.luau

@@ -2,52 +2,52 @@
 --!native
 -- Fixed-size codec factory. Every fixed-size codec calls Base.define once.
 
-local Channel = require (script.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Base = {}
 
-function Base.define <T>(
+function Base.define<T>(
     size: number,
     directWrite: (b: buffer, offset: number, value: T) -> (),
     directRead: (b: buffer, offset: number) -> T
 ): any
-    return table.freeze ({
+    return table.freeze({
         _size = size,
         _directWrite = directWrite,
         _directRead = directRead,
-        write = function (ch: ChannelState, value: T): ()
+        write = function(ch: ChannelState, value: T): ()
             local c = ch.cursor
             if c + size > ch.size then
-                alloc (ch, size)
+                alloc(ch, size)
             end
-            directWrite (ch.buff, c, value)
+            directWrite(ch.buff, c, value)
             ch.cursor = c + size
         end,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (T, number)
-            return directRead (src, pos), size
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (T, number)
+            return directRead(src, pos), size
         end,
     })
 end
 
-function Base.zero (): any
-    return table.freeze ({
+function Base.zero(): any
+    return table.freeze({
         _size = 0,
-        _directWrite = function (_b: buffer, _offset: number, _value: any): () end,
-        _directRead = function (_b: buffer, _offset: number): any
+        _directWrite = function(_b: buffer, _offset: number, _value: any): () end,
+        _directRead = function(_b: buffer, _offset: number): any
             return nil
         end,
-        write = function (_ch: ChannelState, _value: any): () end,
-        read = function (_src: buffer, _pos: number, _refs: { Instance }?): (any, number)
+        write = function(_ch: ChannelState, _value: any): () end,
+        read = function(_src: buffer, _pos: number, _refs: { Instance }?): (any, number)
             return nil, 0
         end,
     })
 end
 
-return table.freeze (Base)
+return table.freeze(Base)