@axpecter/lync 2.3.3 → 3.0.0

package/src/codec/datatype/Sequence.luau

@@ -1,184 +0,0 @@
---!strict
---!native
--- NumberSequence (12B/keypoint) and ColorSequence (7B/keypoint) codecs.
-
-local Base = require(script.Parent.Parent.Base)
-local Constants = require(script.Parent.Parent.Parent.util.Constants)
-local Log = require(script.Parent.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Parent.Types)
-local Varint = require(script.Parent.Parent.primitive.Varint)
-
--- Constants --------------------------------------------------------------
-
-local NUMSEQ_KP_BYTES = 12
-local COLSEQ_KP_BYTES = 7
-local MAX_KEYPOINTS = 20
-
--- Private ----------------------------------------------------------------
-
-local U8_MAX = Constants.U8_MAX
-local alloc = Base.alloc
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-local writeu8 = buffer.writeu8
-local readu8 = buffer.readu8
-local round = math.round
-local clamp = math.clamp
-local varintRead = Varint.read
-local varintWrite = Varint.write
-
---[[
-    Common write prelude: count cap check, varint count, payload alloc.
-    Returns (cursor, b) for the per-keypoint writer; (nil, nil) when count
-    is 0 so callers short-circuit.
-]]
-local function beginSeqWrite(
-    ch: Types.ChannelState,
-    label: string,
-    count: number,
-    kpBytes: number
-): (number?, buffer?)
-    if count > MAX_KEYPOINTS then
-        Log.error(`{label}.write: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`)
-    end
-    varintWrite(ch, count)
-    if count == 0 then
-        return nil, nil
-    end
-
-    local bytes = count * kpBytes
-    local cursor = ch.cursor
-    if cursor + bytes > ch.size then
-        alloc(ch, bytes)
-    end
-    ch.cursor = cursor + bytes
-    return cursor, ch.buff
-end
-
---[[
-    Common read prelude: varint count, cap check, bounds check. Returns
-    (count, dataStart, lenBytes) for the per-keypoint reader; (0, _, lenBytes)
-    when payload is empty.
-]]
-local function beginSeqRead(
-    src: buffer,
-    pos: number,
-    label: string,
-    kpBytes: number
-): (number, number, number)
-    local count, lenBytes = varintRead(src, pos)
-    if count == 0 then
-        return 0, pos + lenBytes, lenBytes
-    end
-    if count > MAX_KEYPOINTS then
-        Log.error(`{label}.read: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`)
-    end
-
-    local bytes = count * kpBytes
-    local dataStart = pos + lenBytes
-    if dataStart + bytes > buffer.len(src) then
-        Log.error(`{label}.read: payload {bytes}B exceeds remaining buffer`)
-    end
-    return count, dataStart, lenBytes
-end
-
-local function writeNumberSequence(ch: Types.ChannelState, value: NumberSequence): ()
-    local keypoints = value.Keypoints
-    local count = #keypoints
-    local cursor, b = beginSeqWrite(ch, "NumberSequence", count, NUMSEQ_KP_BYTES)
-    if not cursor then
-        return
-    end
-    local off = cursor :: number
-    local buf = b :: buffer
-    for i = 1, count do
-        local kp = keypoints[i]
-        writef32(buf, off, kp.Time)
-        writef32(buf, off + 4, kp.Value)
-        writef32(buf, off + 8, kp.Envelope)
-        off += NUMSEQ_KP_BYTES
-    end
-end
-
-local function readNumberSequence(
-    src: buffer,
-    pos: number,
-    _refs: { Instance }?
-): (NumberSequence, number)
-    local count, dataStart, lenBytes = beginSeqRead(src, pos, "NumberSequence", NUMSEQ_KP_BYTES)
-    if count == 0 then
-        return NumberSequence.new(0), lenBytes
-    end
-
-    local keypoints = table.create(count)
-    local off = dataStart
-    for i = 1, count do
-        keypoints[i] = NumberSequenceKeypoint.new(
-            readf32(src, off),
-            readf32(src, off + 4),
-            readf32(src, off + 8)
-        )
-        off += NUMSEQ_KP_BYTES
-    end
-    return NumberSequence.new(keypoints), lenBytes + count * NUMSEQ_KP_BYTES
-end
-
-local function writeColorSequence(ch: Types.ChannelState, value: ColorSequence): ()
-    local keypoints = value.Keypoints
-    local count = #keypoints
-    local cursor, b = beginSeqWrite(ch, "ColorSequence", count, COLSEQ_KP_BYTES)
-    if not cursor then
-        return
-    end
-    local off = cursor :: number
-    local buf = b :: buffer
-    for i = 1, count do
-        local kp = keypoints[i]
-        local c = kp.Value
-        writef32(buf, off, kp.Time)
-        writeu8(buf, off + 4, round(clamp(c.R, 0, 1) * U8_MAX))
-        writeu8(buf, off + 5, round(clamp(c.G, 0, 1) * U8_MAX))
-        writeu8(buf, off + 6, round(clamp(c.B, 0, 1) * U8_MAX))
-        off += COLSEQ_KP_BYTES
-    end
-end
-
-local function readColorSequence(
-    src: buffer,
-    pos: number,
-    _refs: { Instance }?
-): (ColorSequence, number)
-    local count, dataStart, lenBytes = beginSeqRead(src, pos, "ColorSequence", COLSEQ_KP_BYTES)
-    if count == 0 then
-        return ColorSequence.new(Color3.new()), lenBytes
-    end
-
-    local keypoints = table.create(count)
-    local off = dataStart
-    for i = 1, count do
-        keypoints[i] = ColorSequenceKeypoint.new(
-            readf32(src, off),
-            Color3.fromRGB(readu8(src, off + 4), readu8(src, off + 5), readu8(src, off + 6))
-        )
-        off += COLSEQ_KP_BYTES
-    end
-    return ColorSequence.new(keypoints), lenBytes + count * COLSEQ_KP_BYTES
-end
-
--- Public -----------------------------------------------------------------
-
-local Sequence = {}
-
-Sequence.numberSequence = table.freeze({
-    _typeCheck = "NumberSequence",
-    write = writeNumberSequence,
-    read = readNumberSequence,
-})
-
-Sequence.colorSequence = table.freeze({
-    _typeCheck = "ColorSequence",
-    write = writeColorSequence,
-    read = readColorSequence,
-})
-
-return table.freeze(Sequence)

package/src/codec/datatype/String.luau

@@ -1,94 +0,0 @@
---!strict
---!native
--- UTF-8 string codec. __call yields a length-bounded variant.
-
-local Base = require(script.Parent.Parent.Base)
-local Log = require(script.Parent.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Parent.Types)
-local Varint = require(script.Parent.Parent.primitive.Varint)
-
--- Private ----------------------------------------------------------------
-
-local alloc = Base.alloc
-local INLINE_MAX = Varint.INLINE_MAX
-
-local function writeString(ch: Types.ChannelState, value: string): ()
-    local len = #value
-    local cursor = ch.cursor
-
-    -- Single-byte length fast path skips the full varint encode.
-    if len <= INLINE_MAX then
-        if cursor + 1 + len > ch.size then
-            alloc(ch, 1 + len)
-        end
-        local b = ch.buff
-        buffer.writeu8(b, cursor, len)
-        if len > 0 then
-            buffer.writestring(b, cursor + 1, value)
-        end
-        ch.cursor = cursor + 1 + len
-        return
-    end
-
-    Varint.write(ch, len)
-    cursor = ch.cursor
-    if cursor + len > ch.size then
-        alloc(ch, len)
-    end
-    buffer.writestring(ch.buff, cursor, value)
-    ch.cursor = cursor + len
-end
-
-local readLengthPrefix = Varint.readLengthPrefix
-
-local function readString(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-    local len, lenBytes = readLengthPrefix(src, pos)
-    if len == 0 then
-        return "", lenBytes
-    end
-
-    local dataStart = pos + lenBytes
-    if dataStart + len > buffer.len(src) then
-        Log.error(`length {len}B exceeds remaining buffer`)
-    end
-    return buffer.readstring(src, dataStart, len), lenBytes + len
-end
-
--- _maxStringLength lets Gate.validate reject oversized values send-side.
-local function boundedFactory(_self, maxLength: number): Types.InternalCodec<string>
-    Log.assert(maxLength > 0, "maxLength must be positive")
-
-    return table.freeze({
-        _typeCheck = "string",
-        _maxStringLength = maxLength,
-        write = function(ch: Types.ChannelState, value: string): ()
-            if #value > maxLength then
-                Log.error(`length {#value} exceeds max {maxLength}`)
-            end
-            writeString(ch, value)
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-            local len, lenBytes = readLengthPrefix(src, pos)
-            if len > maxLength then
-                Log.error(`length {len} exceeds max {maxLength}`)
-            end
-            if len == 0 then
-                return "", lenBytes
-            end
-
-            local dataStart = pos + lenBytes
-            if dataStart + len > buffer.len(src) then
-                Log.error(`length {len}B exceeds remaining buffer`)
-            end
-            return buffer.readstring(src, dataStart, len), lenBytes + len
-        end,
-    })
-end
-
--- Public -----------------------------------------------------------------
-
-return table.freeze(setmetatable({
-    _typeCheck = "string",
-    write = writeString,
-    read = readString,
-}, table.freeze({ __call = boundedFactory })))

package/src/codec/datatype/UDim.luau

@@ -1,46 +0,0 @@
---!strict
---!native
--- UDim (8B) and UDim2 (16B) codecs. Scale = f32, Offset = i32.
-
-local Base = require(script.Parent.Parent.Base)
-local Signed = require(script.Parent.Parent.primitive.Signed)
-
--- Private ----------------------------------------------------------------
-
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-local writeI32 = Signed.writeI32
-local readi32 = buffer.readi32
-
-local function writeUDim(b: buffer, off: number, value: UDim): ()
-    writef32(b, off, value.Scale)
-    writeI32(b, off + 4, value.Offset)
-end
-
-local function readUDim(b: buffer, off: number): UDim
-    return UDim.new(readf32(b, off), readi32(b, off + 4))
-end
-
-local function writeUDim2(b: buffer, off: number, value: UDim2): ()
-    local x, y = value.X, value.Y
-    writef32(b, off, x.Scale)
-    writeI32(b, off + 4, x.Offset)
-    writef32(b, off + 8, y.Scale)
-    writeI32(b, off + 12, y.Offset)
-end
-
-local function readUDim2(b: buffer, off: number): UDim2
-    return UDim2.new(
-        UDim.new(readf32(b, off), readi32(b, off + 4)),
-        UDim.new(readf32(b, off + 8), readi32(b, off + 12))
-    )
-end
-
--- Public -----------------------------------------------------------------
-
-local UDimCodec = {}
-
-UDimCodec.udim = Base.define(8, writeUDim, readUDim, { _typeCheck = "UDim" })
-UDimCodec.udim2 = Base.define(16, writeUDim2, readUDim2, { _typeCheck = "UDim2" })
-
-return table.freeze(UDimCodec)

package/src/codec/datatype/Vector.luau

@@ -1,130 +0,0 @@
---!strict
---!native
--- Vector2 / Vector3 codecs. __call yields a quantized variant.
-
-local Base = require(script.Parent.Parent.Base)
-local Quantize = require(script.Parent.Parent.Parent.util.Quantize)
-local Types = require(script.Parent.Parent.Parent.Types)
-
--- Private ----------------------------------------------------------------
-
-local alloc = Base.alloc
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-local clamp = math.clamp
-local round = math.round
-
-local function writeVec2(b: buffer, off: number, value: Vector2): ()
-    writef32(b, off, value.X)
-    writef32(b, off + 4, value.Y)
-end
-
-local function readVec2(b: buffer, off: number): Vector2
-    return Vector2.new(readf32(b, off), readf32(b, off + 4))
-end
-
-local function writeVec3(b: buffer, off: number, value: Vector3): ()
-    writef32(b, off, value.X)
-    writef32(b, off + 4, value.Y)
-    writef32(b, off + 8, value.Z)
-end
-
-local function readVec3(b: buffer, off: number): Vector3
-    return Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8))
-end
-
-local function quantizeVec2(
-    _self,
-    rangeMin: number,
-    rangeMax: number,
-    precision: number
-): Types.InternalCodec<Vector2>
-    -- Degenerate range: emit nothing, decode to the constant.
-    if rangeMax - rangeMin == 0 then
-        return Base.constant(Vector2.new(rangeMin, rangeMin))
-    end
-
-    local compBytes, wfn, rfn, scale, invScale, delta =
-        Quantize.setup("Lync.vec2", rangeMin, rangeMax, precision)
-    local totalSize = compBytes * 2
-
-    return Base.define(totalSize, function(b: buffer, off: number, value: Vector2): ()
-        wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
-        wfn(b, off + compBytes, round(clamp(value.Y - rangeMin, 0, delta) * scale))
-    end, function(b: buffer, off: number): Vector2
-        return Vector2.new(
-            rfn(b, off) * invScale + rangeMin,
-            rfn(b, off + compBytes) * invScale + rangeMin
-        )
-    end, { _typeCheck = "Vector2", _min = rangeMin, _max = rangeMax })
-end
-
-local function quantizeVec3(
-    _self,
-    rangeMin: number,
-    rangeMax: number,
-    precision: number
-): Types.InternalCodec<Vector3>
-    if rangeMax - rangeMin == 0 then
-        return Base.constant(Vector3.new(rangeMin, rangeMin, rangeMin))
-    end
-
-    local compBytes, wfn, rfn, scale, invScale, delta =
-        Quantize.setup("Lync.vec3", rangeMin, rangeMax, precision)
-    local totalSize = compBytes * 3
-    local off2 = compBytes * 2
-
-    return Base.define(totalSize, function(b: buffer, off: number, value: Vector3): ()
-        wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
-        wfn(b, off + compBytes, round(clamp(value.Y - rangeMin, 0, delta) * scale))
-        wfn(b, off + off2, round(clamp(value.Z - rangeMin, 0, delta) * scale))
-    end, function(b: buffer, off: number): Vector3
-        return Vector3.new(
-            rfn(b, off) * invScale + rangeMin,
-            rfn(b, off + compBytes) * invScale + rangeMin,
-            rfn(b, off + off2) * invScale + rangeMin
-        )
-    end, { _typeCheck = "Vector3", _min = rangeMin, _max = rangeMax })
-end
-
--- Public -----------------------------------------------------------------
-
-local VectorCodec = {}
-
-VectorCodec.vec2 = table.freeze(setmetatable({
-    _size = 8,
-    _directWrite = writeVec2,
-    _directRead = readVec2,
-    _typeCheck = "Vector2",
-    write = function(ch: Types.ChannelState, value: Vector2): ()
-        local cursor = ch.cursor
-        if cursor + 8 > ch.size then
-            alloc(ch, 8)
-        end
-        writeVec2(ch.buff, cursor, value)
-        ch.cursor = cursor + 8
-    end,
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector2, number)
-        return readVec2(src, pos), 8
-    end,
-}, table.freeze({ __call = quantizeVec2 })))
-
-VectorCodec.vec3 = table.freeze(setmetatable({
-    _size = 12,
-    _directWrite = writeVec3,
-    _directRead = readVec3,
-    _typeCheck = "Vector3",
-    write = function(ch: Types.ChannelState, value: Vector3): ()
-        local cursor = ch.cursor
-        if cursor + 12 > ch.size then
-            alloc(ch, 12)
-        end
-        writeVec3(ch.buff, cursor, value)
-        ch.cursor = cursor + 12
-    end,
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
-        return readVec3(src, pos), 12
-    end,
-}, table.freeze({ __call = quantizeVec3 })))
-
-return table.freeze(VectorCodec)