@axpecter/lync 2.2.0 → 2.3.1

package/src/util/Constants.luau

@@ -0,0 +1,30 @@
+--!strict
+--!optimize 2
+-- Wire-format constants and integer limits shared across codecs.
+
+-- Public -----------------------------------------------------------------
+
+local Constants = {}
+
+Constants.U8_MAX = 0xFF
+Constants.U16_MAX = 0xFFFF
+Constants.U32_MAX = 0xFFFFFFFF
+
+Constants.I8_MIN = -0x80
+Constants.I8_MAX = 0x7F
+Constants.I16_MIN = -0x8000
+Constants.I16_MAX = 0x7FFF
+Constants.I32_MIN = -0x80000000
+Constants.I32_MAX = 0x7FFFFFFF
+
+--[[
+    Frame header byte: MSB = single-item (no count cell); cleared = multi-item
+    (u16 count follows). Low 7 bits = registration id (caps registry at 128).
+]]
+Constants.FRAME_MSB = 0x80
+Constants.FRAME_ID_MASK = 0x7F
+
+-- u16 count cell.
+Constants.MAX_BATCH_ITEMS = 0xFFFF
+
+return table.freeze(Constants)

package/src/util/Log.luau

@@ -0,0 +1,68 @@
+--!strict
+--!optimize 2
+-- Centralized warn/error/assert. Project name + caller source come from here.
+
+-- State ------------------------------------------------------------------
+
+-- Module-level so tests mute the whole library without threading a flag.
+local _silent = false
+
+-- Constants --------------------------------------------------------------
+
+local PREFIX = "[Lync]"
+
+-- Private ----------------------------------------------------------------
+
+--[[
+    Stack levels: 1=this fn, 2=Log.warn/error/assert, 3=user. We want #3 so
+    the source/line/name point at the actual caller, not at Log.
+
+    Source comes back as a dotted Roblox path (e.g. "ServerScriptService.
+    MainModule.Lync.codec.primitive.Int" or "...test.unit.api.Packet.spec").
+    `.spec` is a literal dot in test ModuleScript names, so split-on-dot
+    would yield the meaningless tail "spec"; check the .spec suffix first
+    and recover the meaningful segment, then fall back to the last segment.
+]]
+local function format(message: string): string
+    local source, line, name = debug.info(3, "sln")
+    local file = source:match("([^.]+)%.spec$") or source:match("[^./\\]+$") or source
+    if name and name ~= "" then
+        return `{PREFIX} {file}:{line} ({name}) {message}`
+    end
+    return `{PREFIX} {file}:{line} {message}`
+end
+
+-- Public -----------------------------------------------------------------
+
+local Log = {}
+
+function Log.warn(message: string): ()
+    if not _silent then
+        warn(format(message))
+    end
+end
+
+-- level 2 so the runtime traceback points at the caller, not at Log.
+function Log.error(message: string): never
+    error(format(message), 2)
+end
+
+--[[
+    NOTE: Luau evaluates args eagerly. `format(message)` runs even when cond
+    is true, paying one debug.info call per Log.assert call. Use only with
+    LITERAL strings (no interpolation). For interpolated messages prefer
+    `if cond then Log.error(...) end`.
+]]
+function Log.assert<T>(cond: T, message: string): T
+    return assert(cond, format(message))
+end
+
+function Log.setSilent(silent: boolean): ()
+    _silent = silent
+end
+
+function Log.reset(): ()
+    _silent = false
+end
+
+return table.freeze(Log)

package/src/util/Player.luau

@@ -0,0 +1,14 @@
+--!strict
+--!optimize 2
+-- Player Instance type guard.
+
+-- Public -----------------------------------------------------------------
+
+local Player = {}
+
+-- typeof first: :IsA errors on non-Instances.
+function Player.is(value: any): boolean
+    return typeof(value) == "Instance" and value:IsA("Player")
+end
+
+return table.freeze(Player)

package/src/util/Quantize.luau

@@ -0,0 +1,60 @@
+--!strict
+--!optimize 2
+-- Fixed-point range quantizer setup shared by float and vector codecs.
+
+local Log = require(script.Parent.Log)
+
+-- Private ----------------------------------------------------------------
+
+local ceil = math.ceil
+local maxN = math.max
+local minN = math.min
+
+-- Public -----------------------------------------------------------------
+
+local Quantize = {}
+
+--[[
+    Pick the narrowest u8/u16/u32 wire form for [rangeMin, rangeMax] at
+    `precision`. Returns (compBytes, wfn, rfn, scale, invScale, delta).
+    `apiName` shows in error messages so callers see their public surface.
+]]
+function Quantize.setup(
+    apiName: string,
+    rangeMin: number,
+    rangeMax: number,
+    precision: number
+): (
+    number,
+    (buffer, number, number) -> (),
+    (buffer, number) -> number,
+    number,
+    number,
+    number
+)
+    if rangeMin > rangeMax then
+        Log.error(`{apiName}: min ({rangeMin}) must be <= max ({rangeMax})`)
+    end
+    if precision <= 0 then
+        Log.error(`{apiName}: precision must be positive, got {precision}`)
+    end
+
+    local delta = rangeMax - rangeMin
+    -- Clamp to [1, U32_MAX] so wire-form selection has a valid value.
+    local maxInt = minN(0xFFFFFFFF, maxN(1, ceil(delta / precision)))
+
+    local compBytes: number
+    local wfn: (buffer, number, number) -> ()
+    local rfn: (buffer, number) -> number
+    if maxInt <= 0xFF then
+        compBytes, wfn, rfn = 1, buffer.writeu8, buffer.readu8
+    elseif maxInt <= 0xFFFF then
+        compBytes, wfn, rfn = 2, buffer.writeu16, buffer.readu16
+    else
+        compBytes, wfn, rfn = 4, buffer.writeu32, buffer.readu32
+    end
+
+    return compBytes, wfn, rfn, maxInt / delta, delta / maxInt, delta
+end
+
+return table.freeze(Quantize)

package/src/internal/Util.luau

@@ -1,26 +0,0 @@
---!strict
---!optimize 2
--- Cross-module utility helpers.
-
--- Public -----------------------------------------------------------------
-
-local Util = {}
-
-function Util.isPlayer(value: any): boolean
-    return typeof(value) == "Instance" and (value :: Instance):IsA("Player")
-end
-
---[[
-    O(1) array remove via swap with last element. The slot becomes nil
-    after this returns; callers that track an external count must
-    decrement it themselves.
-]]
-function Util.swapRemove<T>(arr: { T }, idx: number): ()
-    local last = #arr
-    if idx ~= last then
-        arr[idx] = arr[last]
-    end
-    arr[last] = nil
-end
-
-return table.freeze(Util)