@axpecter/lync 1.4.1 → 1.5.0

package/src/codec/composite/Map.luau

@@ -2,11 +2,11 @@
 --!native
 -- map and deltaMap codecs.
 
-local Baseline = require (script.Parent.Parent.Parent.internal.Baseline)
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Shared = require (script.Parent.Shared)
-local Types = require (script.Parent.Parent.Parent.Types)
-local Varint = require (script.Parent.Parent.primitive.Varint)
+local Baseline = require(script.Parent.Parent.Parent.internal.Baseline)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Shared = require(script.Parent.Shared)
+local Types = require(script.Parent.Parent.Parent.Types)
+local Varint = require(script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
@@ -21,11 +21,11 @@ local FLAG_DELTA = Shared.FLAG_DELTA
 local FLAG_FULL = Shared.FLAG_FULL
 local FLAG_UNCHANGED = Shared.FLAG_UNCHANGED
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Map = {}
 
-function Map.map (
+function Map.map(
     keyCodec: Codec<any>,
     valueCodec: Codec<any>,
     maxCount: number?
@@ -43,48 +43,48 @@ function Map.map (
     if keySize and valSize and keyDWrite and valDWrite and keyDRead and valDRead then
         local entrySize = keySize + valSize
 
-        return table.freeze ({
-            write = function (ch: ChannelState, value: { [any]: any }): ()
+        return table.freeze({
+            write = function(ch: ChannelState, value: { [any]: any }): ()
                 local count = 0
                 for _ in value do
                     count += 1
                 end
 
-                Varint.write (ch, count)
+                Varint.write(ch, count)
 
                 if count > 0 then
                     local totalBytes = count * entrySize
                     local c = ch.cursor
                     if c + totalBytes > ch.size then
-                        alloc (ch, totalBytes)
+                        alloc(ch, totalBytes)
                     end
 
                     local b = ch.buff
                     for k, v in value do
-                        keyDWrite (b, c, k)
-                        valDWrite (b, c + keySize, v)
+                        keyDWrite(b, c, k)
+                        valDWrite(b, c + keySize, v)
                         c += entrySize
                     end
                     ch.cursor = c
                 end
             end,
-            read = function (
+            read = function(
                 src: buffer,
                 pos: number,
                 _refs: { Instance }?
             ): ({ [any]: any }, number)
-                local count, lenBytes = Varint.read (src, pos)
+                local count, lenBytes = Varint.read(src, pos)
 
                 if maxCount and count > maxCount then
-                    error (`[Lync] Map count {count} exceeds max {maxCount}`)
+                    error(`[Lync] Map count {count} exceeds max {maxCount}`)
                 end
 
                 local result = {}
                 local c = pos + lenBytes
 
                 for _ = 1, count do
-                    local k = keyDRead (src, c)
-                    local v = valDRead (src, c + keySize)
+                    local k = keyDRead(src, c)
+                    local v = valDRead(src, c + keySize)
                     result[k] = v
                     c += entrySize
                 end
@@ -99,34 +99,34 @@ function Map.map (
     local readKey = keyCodec.read
     local readVal = valueCodec.read
 
-    return table.freeze ({
-        write = function (ch: ChannelState, value: { [any]: any }): ()
+    return table.freeze({
+        write = function(ch: ChannelState, value: { [any]: any }): ()
             local count = 0
             for _ in value do
                 count += 1
             end
 
-            Varint.write (ch, count)
+            Varint.write(ch, count)
 
             for k, v in value do
-                writeKey (ch, k)
-                writeVal (ch, v)
+                writeKey(ch, k)
+                writeVal(ch, v)
             end
         end,
-        read = function (src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
-            local count, lenBytes = Varint.read (src, pos)
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
+            local count, lenBytes = Varint.read(src, pos)
 
             if maxCount and count > maxCount then
-                error (`[Lync] Map count {count} exceeds max {maxCount}`)
+                error(`[Lync] Map count {count} exceeds max {maxCount}`)
             end
 
             local result = {}
             local absPos = pos + lenBytes
 
             for _ = 1, count do
-                local k, kn = readKey (src, absPos, refs)
+                local k, kn = readKey(src, absPos, refs)
                 absPos += kn
-                local v, vn = readVal (src, absPos, refs)
+                local v, vn = readVal(src, absPos, refs)
                 absPos += vn
                 result[k] = v
             end
@@ -144,12 +144,12 @@ end
       FLAG_UNCHANGED: u8(2)
       FLAG_DELTA:     u8(0) + varint(upsertN) + [key+value ...] + varint(removeN) + [key ...]
 ]]
-function Map.deltaMap (
+function Map.deltaMap(
     keyCodec: Codec<any>,
     valueCodec: Codec<any>,
     maxCount: number?
 ): Codec<{ [any]: any }>
-    local deltaId = Shared.allocDeltaId ()
+    local deltaId = Shared.allocDeltaId()
 
     local writeKey = keyCodec.write
     local writeVal = valueCodec.write
@@ -183,11 +183,11 @@ function Map.deltaMap (
         count: number,
     }
 
-    return table.freeze ({
+    return table.freeze({
         _isDelta = true,
 
-        write = function (ch: ChannelState, value: { [any]: any }): ()
-            local scratch = acquireScratch ()
+        write = function(ch: ChannelState, value: { [any]: any }): ()
+            local scratch = acquireScratch()
 
             local entries = {} :: { EntryBounds }
             local keyLookup = {} :: { [string]: number }
@@ -197,10 +197,10 @@ function Map.deltaMap (
                 for k, v in value do
                     entryCount += 1
                     local c = scratch.cursor
-                    alloc (scratch, entrySize :: number)
+                    alloc(scratch, entrySize :: number)
                     local b = scratch.buff
-                    keyDWrite (b, c, k)
-                    valDWrite (b, c + (keySize :: number), v)
+                    keyDWrite(b, c, k)
+                    valDWrite(b, c + (keySize :: number), v)
                     scratch.cursor = c + (entrySize :: number)
 
                     entries[entryCount] = {
@@ -210,16 +210,16 @@ function Map.deltaMap (
                         valLen = valSize :: number,
                     }
 
-                    local keyId = buffer.readstring (b, c, keySize :: number)
+                    local keyId = buffer.readstring(b, c, keySize :: number)
                     keyLookup[keyId] = entryCount
                 end
             else
                 for k, v in value do
                     entryCount += 1
                     local keyStart = scratch.cursor
-                    writeKey (scratch, k)
+                    writeKey(scratch, k)
                     local keyEnd = scratch.cursor
-                    writeVal (scratch, v)
+                    writeVal(scratch, v)
                     local valEnd = scratch.cursor
 
                     entries[entryCount] = {
@@ -229,7 +229,7 @@ function Map.deltaMap (
                         valLen = valEnd - keyEnd,
                     }
 
-                    local keyId = buffer.readstring (scratch.buff, keyStart, keyEnd - keyStart)
+                    local keyId = buffer.readstring(scratch.buff, keyStart, keyEnd - keyStart)
                     keyLookup[keyId] = entryCount
                 end
             end
@@ -238,14 +238,14 @@ function Map.deltaMap (
             local cache = ch.deltas[deltaId] :: DeltaMapCache?
 
             if not cache then
-                alloc (ch, 1)
-                buffer.writeu8 (ch.buff, ch.cursor, FLAG_FULL)
+                alloc(ch, 1)
+                buffer.writeu8(ch.buff, ch.cursor, FLAG_FULL)
                 ch.cursor += 1
-                Varint.write (ch, entryCount)
+                Varint.write(ch, entryCount)
 
                 if scratchTotal > 0 then
-                    alloc (ch, scratchTotal)
-                    buffer.copy (ch.buff, ch.cursor, scratch.buff, 0, scratchTotal)
+                    alloc(ch, scratchTotal)
+                    buffer.copy(ch.buff, ch.cursor, scratch.buff, 0, scratchTotal)
                     ch.cursor += scratchTotal
                 end
             else
@@ -266,7 +266,7 @@ function Map.deltaMap (
                         local oldE = cacheEntries[oldIdx]
                         if
                             newE.valLen ~= oldE.valLen
-                            or not rangeEqual (
+                            or not rangeEqual(
                                 scratch.buff,
                                 newE.valOff,
                                 cacheRaw,
@@ -291,40 +291,40 @@ function Map.deltaMap (
                 end
 
                 if upsertN == 0 and removeN == 0 then
-                    alloc (ch, 1)
-                    buffer.writeu8 (ch.buff, ch.cursor, FLAG_UNCHANGED)
+                    alloc(ch, 1)
+                    buffer.writeu8(ch.buff, ch.cursor, FLAG_UNCHANGED)
                     ch.cursor += 1
-                    releaseScratch ()
+                    releaseScratch()
                     return
                 end
 
-                alloc (ch, 1)
-                buffer.writeu8 (ch.buff, ch.cursor, FLAG_DELTA)
+                alloc(ch, 1)
+                buffer.writeu8(ch.buff, ch.cursor, FLAG_DELTA)
                 ch.cursor += 1
 
-                Varint.write (ch, upsertN)
+                Varint.write(ch, upsertN)
                 for i = 1, upsertN do
                     local e = entries[upsertKeys[i]]
                     local totalLen = e.keyLen + e.valLen
-                    alloc (ch, totalLen)
-                    buffer.copy (ch.buff, ch.cursor, scratch.buff, e.keyOff, totalLen)
+                    alloc(ch, totalLen)
+                    buffer.copy(ch.buff, ch.cursor, scratch.buff, e.keyOff, totalLen)
                     ch.cursor += totalLen
                 end
 
-                Varint.write (ch, removeN)
+                Varint.write(ch, removeN)
                 for i = 1, removeN do
                     local keyId = removeKeyIds[i]
                     local oldIdx = cacheLookup[keyId]
                     local oldE = cacheEntries[oldIdx]
-                    alloc (ch, oldE.keyLen)
-                    buffer.copy (ch.buff, ch.cursor, cacheRaw, oldE.keyOff, oldE.keyLen)
+                    alloc(ch, oldE.keyLen)
+                    buffer.copy(ch.buff, ch.cursor, cacheRaw, oldE.keyOff, oldE.keyLen)
                     ch.cursor += oldE.keyLen
                 end
             end
 
-            local rawBuf = buffer.create (scratchTotal)
+            local rawBuf = buffer.create(scratchTotal)
             if scratchTotal > 0 then
-                buffer.copy (rawBuf, 0, scratch.buff, 0, scratchTotal)
+                buffer.copy(rawBuf, 0, scratch.buff, 0, scratchTotal)
             end
 
             ch.deltas[deltaId] = {
@@ -334,76 +334,76 @@ function Map.deltaMap (
                 count = entryCount,
             }
 
-            releaseScratch ()
+            releaseScratch()
         end,
 
-        read = function (src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
-            local flag = buffer.readu8 (src, pos)
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
+            local flag = buffer.readu8(src, pos)
             local absPos = pos + 1
 
             if flag == FLAG_UNCHANGED then
-                local cache = Baseline.getCache (deltaId)
-                return if cache then table.clone (cache) else {}, 1
+                local cache = Baseline.getCache(deltaId)
+                return if cache then table.clone(cache) else {}, 1
             end
 
             if flag == FLAG_FULL then
-                local count, lenBytes = Varint.read (src, absPos)
+                local count, lenBytes = Varint.read(src, absPos)
                 absPos += lenBytes
 
                 if maxCount and count > maxCount then
-                    error (`[Lync] Map count {count} exceeds max {maxCount}`)
+                    error(`[Lync] Map count {count} exceeds max {maxCount}`)
                 end
 
                 local result = {}
 
                 if keyDRead and valDRead and keySize and valSize then
                     for _ = 1, count do
-                        local k = keyDRead (src, absPos)
-                        local v = valDRead (src, absPos + keySize)
+                        local k = keyDRead(src, absPos)
+                        local v = valDRead(src, absPos + keySize)
                         result[k] = v
                         absPos += entrySize :: number
                     end
                 else
                     for _ = 1, count do
-                        local k, kn = readKey (src, absPos, refs)
+                        local k, kn = readKey(src, absPos, refs)
                         absPos += kn
-                        local v, vn = readVal (src, absPos, refs)
+                        local v, vn = readVal(src, absPos, refs)
                         absPos += vn
                         result[k] = v
                     end
                 end
 
-                Baseline.setCache (deltaId, result)
+                Baseline.setCache(deltaId, result)
                 return result, absPos - pos
             end
 
-            local cache = Baseline.getCache (deltaId) :: { [any]: any }?
-            local result = if cache then table.clone (cache) else {}
+            local cache = Baseline.getCache(deltaId) :: { [any]: any }?
+            local result = if cache then table.clone(cache) else {}
 
-            local upsertN, unBytes = Varint.read (src, absPos)
+            local upsertN, unBytes = Varint.read(src, absPos)
             absPos += unBytes
 
             for _ = 1, upsertN do
-                local k, kn = readKey (src, absPos, refs)
+                local k, kn = readKey(src, absPos, refs)
                 absPos += kn
-                local v, vn = readVal (src, absPos, refs)
+                local v, vn = readVal(src, absPos, refs)
                 absPos += vn
                 result[k] = v
             end
 
-            local removeN, rmBytes = Varint.read (src, absPos)
+            local removeN, rmBytes = Varint.read(src, absPos)
             absPos += rmBytes
 
             for _ = 1, removeN do
-                local k, kn = readKey (src, absPos, refs)
+                local k, kn = readKey(src, absPos, refs)
                 absPos += kn
                 result[k] = nil
             end
 
-            Baseline.setCache (deltaId, result)
+            Baseline.setCache(deltaId, result)
             return result, absPos - pos
         end,
     })
 end
 
-return table.freeze (Map)
+return table.freeze(Map)

package/src/codec/composite/Optional.luau

@@ -2,47 +2,47 @@
 --!native
 -- Optional codec. 1 byte flag, value only if present.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+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
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Optional = {}
 
-function Optional.optional (inner: Codec<any>): Codec<any>
+function Optional.optional(inner: Codec<any>): Codec<any>
     local innerWrite = inner.write
     local innerRead = inner.read
 
-    return table.freeze ({
-        write = function (ch: ChannelState, value: any): ()
+    return table.freeze({
+        write = function(ch: ChannelState, value: any): ()
             local c = ch.cursor
             if c + 1 > ch.size then
-                alloc (ch, 1)
+                alloc(ch, 1)
             end
             if value == nil then
-                buffer.writeu8 (ch.buff, c, 0)
+                buffer.writeu8(ch.buff, c, 0)
                 ch.cursor = c + 1
             else
-                buffer.writeu8 (ch.buff, c, 1)
+                buffer.writeu8(ch.buff, c, 1)
                 ch.cursor = c + 1
-                innerWrite (ch, value)
+                innerWrite(ch, value)
             end
         end,
-        read = function (src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local flag = buffer.readu8 (src, pos)
+        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+            local flag = buffer.readu8(src, pos)
             if flag == 0 then
                 return nil, 1
             end
 
-            local value, n = innerRead (src, pos + 1, refs)
+            local value, n = innerRead(src, pos + 1, refs)
             return value, 1 + n
         end,
     })
 end
 
-return table.freeze (Optional)
+return table.freeze(Optional)

package/src/codec/composite/Shared.luau

@@ -2,14 +2,14 @@
 --!native
 -- Shared helpers for composite codecs: delta flags, scratch pool, struct field extraction, bool packing.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
@@ -21,13 +21,13 @@ local FLAG_DELTA = 0
 local FLAG_FULL = 1
 local FLAG_UNCHANGED = 2
 
--- State --------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _nextDeltaId = 1
 local _scratchStack = {} :: { ChannelState }
 local _scratchDepth = 0
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Shared = {
     FLAG_DELTA = FLAG_DELTA,
@@ -35,38 +35,38 @@ local Shared = {
     FLAG_UNCHANGED = FLAG_UNCHANGED,
 }
 
-function Shared.allocDeltaId (): number
+function Shared.allocDeltaId(): number
     local id = _nextDeltaId
     _nextDeltaId += 1
     return id
 end
 
-function Shared.acquireScratch (): ChannelState
+function Shared.acquireScratch(): ChannelState
     _scratchDepth += 1
     local scratch = _scratchStack[_scratchDepth]
     if not scratch then
-        scratch = Channel.create ()
+        scratch = Channel.create()
         _scratchStack[_scratchDepth] = scratch
     end
     scratch.cursor = 0
-    table.clear (scratch.refs)
+    table.clear(scratch.refs)
     return scratch
 end
 
-function Shared.releaseScratch (): ()
+function Shared.releaseScratch(): ()
     _scratchDepth -= 1
 end
 
-function Shared.rangeEqual (a: buffer, offA: number, b: buffer, offB: number, len: number): boolean
-    local aligned = band (len, 0xFFFFFFFC)
+function Shared.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len: number): boolean
+    local aligned = band(len, 0xFFFFFFFC)
     for i = 0, aligned - 4, 4 do
-        if buffer.readu32 (a, offA + i) ~= buffer.readu32 (b, offB + i) then
+        if buffer.readu32(a, offA + i) ~= buffer.readu32(b, offB + i) then
             return false
         end
     end
 
     for i = aligned, len - 1 do
-        if buffer.readu8 (a, offA + i) ~= buffer.readu8 (b, offB + i) then
+        if buffer.readu8(a, offA + i) ~= buffer.readu8(b, offB + i) then
             return false
         end
     end
@@ -74,80 +74,80 @@ function Shared.rangeEqual (a: buffer, offA: number, b: buffer, offB: number, le
     return true
 end
 
-function Shared.extractFields (schema: { [string]: any }): ({ string }, { any }, { string })
+function Shared.extractFields(schema: { [string]: any }): ({ string }, { any }, { string })
     local dataKeys = {} :: { string }
     local dataCodecs = {} :: { any }
     local boolKeys = {} :: { string }
 
     for key, codec in schema do
         if codec._isBool then
-            table.insert (boolKeys, key)
+            table.insert(boolKeys, key)
         else
-            table.insert (dataKeys, key)
+            table.insert(dataKeys, key)
         end
     end
 
-    table.sort (dataKeys)
-    table.sort (boolKeys)
+    table.sort(dataKeys)
+    table.sort(boolKeys)
 
     if #dataKeys == 0 and #boolKeys == 0 then
-        error ("[Lync] Struct requires at least one field")
+        error("[Lync] Struct requires at least one field")
     end
 
     for i = 1, #dataKeys do
         dataCodecs[i] = schema[dataKeys[i]]
     end
 
-    table.freeze (dataKeys)
-    table.freeze (dataCodecs)
-    table.freeze (boolKeys)
+    table.freeze(dataKeys)
+    table.freeze(dataCodecs)
+    table.freeze(boolKeys)
 
     return dataKeys, dataCodecs, boolKeys
 end
 
-function Shared.packBools (ch: ChannelState, boolKeys: { string }, boolCount: number, value: any): ()
-    local boolByteCount = ceil (boolCount / 8)
-    alloc (ch, boolByteCount)
+function Shared.packBools(ch: ChannelState, boolKeys: { string }, boolCount: number, value: any): ()
+    local boolByteCount = ceil(boolCount / 8)
+    alloc(ch, boolByteCount)
     local b = ch.buff
     local c = ch.cursor
 
     for byteIdx = 0, boolByteCount - 1 do
         local packed = 0
         local base = byteIdx * 8
-        local limit = min (8, boolCount - base)
+        local limit = min(8, boolCount - base)
 
         for bit = 0, limit - 1 do
             if value[boolKeys[base + bit + 1]] then
-                packed = bor (packed, lshift (1, bit))
+                packed = bor(packed, lshift(1, bit))
             end
         end
 
-        buffer.writeu8 (b, c + byteIdx, packed)
+        buffer.writeu8(b, c + byteIdx, packed)
     end
 
     ch.cursor = c + boolByteCount
 end
 
-function Shared.unpackBools (
+function Shared.unpackBools(
     src: buffer,
     pos: number,
     boolKeys: { string },
     boolCount: number,
     result: any
 ): number
-    local boolByteCount = ceil (boolCount / 8)
+    local boolByteCount = ceil(boolCount / 8)
 
     for byteIdx = 0, boolByteCount - 1 do
-        local byte = buffer.readu8 (src, pos + byteIdx)
+        local byte = buffer.readu8(src, pos + byteIdx)
         local base = byteIdx * 8
-        local limit = min (8, boolCount - base)
+        local limit = min(8, boolCount - base)
 
         for bit = 0, limit - 1 do
-            result[boolKeys[base + bit + 1]] = band (byte, lshift (1, bit)) ~= 0
+            result[boolKeys[base + bit + 1]] = band(byte, lshift(1, bit)) ~= 0
         end
     end
 
     return boolByteCount
 end
 
-return table.freeze (Shared)
+return table.freeze(Shared)