@quenty/timesyncservice 13.18.2 → 13.18.3-canary.550.afa1b3b.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [13.18.3-canary.550.afa1b3b.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/timesyncservice@13.18.2...@quenty/timesyncservice@13.18.3-canary.550.afa1b3b.0) (2025-04-10)
+
+**Note:** Version bump only for package @quenty/timesyncservice
+
+
+
+
+
 ## [13.18.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/timesyncservice@13.18.0...@quenty/timesyncservice@13.18.2) (2025-04-07)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/timesyncservice",
-  "version": "13.18.2",
+  "version": "13.18.3-canary.550.afa1b3b.0",
   "description": "Quenty's TimeSyncService keeps time synchronized between all clients and the server",
   "keywords": [
     "Roblox",
@@ -26,18 +26,18 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "^10.8.2",
-    "@quenty/loader": "^10.8.2",
-    "@quenty/maid": "^3.4.2",
-    "@quenty/promise": "^10.10.3",
-    "@quenty/remoting": "^12.18.2",
-    "@quenty/rx": "^13.17.2",
-    "@quenty/signal": "^7.10.2",
-    "@quenty/table": "^3.7.3",
-    "@quenty/valueobject": "^13.17.2"
+    "@quenty/baseobject": "10.8.3-canary.550.afa1b3b.0",
+    "@quenty/loader": "10.8.3-canary.550.afa1b3b.0",
+    "@quenty/maid": "3.4.3-canary.550.afa1b3b.0",
+    "@quenty/promise": "10.10.4-canary.550.afa1b3b.0",
+    "@quenty/remoting": "12.18.3-canary.550.afa1b3b.0",
+    "@quenty/rx": "13.17.3-canary.550.afa1b3b.0",
+    "@quenty/signal": "7.10.3-canary.550.afa1b3b.0",
+    "@quenty/table": "3.7.4-canary.550.afa1b3b.0",
+    "@quenty/valueobject": "13.17.3-canary.550.afa1b3b.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "64def70499ec067077ee39f279936b620b217847"
+  "gitHead": "afa1b3b99b862698c3ab46009497bd507150867c"
 }

package/src/Shared/Clocks/MasterClock.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Master clock on the server
 	@class MasterClock
@@ -7,11 +8,23 @@ local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
 local Rx = require("Rx")
+local _Observable = require("Observable")
 
 local MasterClock = setmetatable({}, BaseObject)
 MasterClock.__index = MasterClock
 MasterClock.ClassName = "MasterClock"
 
+export type ClockFunction = () -> number
+
+export type MasterClock = typeof(setmetatable(
+	{} :: {
+		_remoteEvent: RemoteEvent,
+		_remoteFunction: RemoteFunction,
+		_clockFunction: ClockFunction,
+	},
+	{} :: typeof({ __index = MasterClock })
+)) & BaseObject.BaseObject
+
 --[=[
 	Constructs a new MasterClock
 
@@ -19,8 +32,8 @@ MasterClock.ClassName = "MasterClock"
 	@param remoteFunction RemoteFunction
 	@return MasterClock
 ]=]
-function MasterClock.new(remoteEvent: RemoteEvent, remoteFunction: RemoteFunction)
-	local self = setmetatable(BaseObject.new(), MasterClock)
+function MasterClock.new(remoteEvent: RemoteEvent, remoteFunction: RemoteFunction): MasterClock
+	local self: MasterClock = setmetatable(BaseObject.new() :: any, MasterClock)
 
 	self._remoteEvent = remoteEvent or error("No remoteEvent")
 	self._remoteFunction = remoteFunction or error("No remoteFunction")
@@ -56,7 +69,7 @@ end
 
 	@return function
 ]=]
-function MasterClock:GetClockFunction()
+function MasterClock.GetClockFunction(self: MasterClock): ClockFunction
 	return self._clockFunction
 end
 
@@ -65,15 +78,15 @@ end
 
 	@return Observable<number>
 ]=]
-function MasterClock:ObservePing()
-	return Rx.of(0)
+function MasterClock.ObservePing(_self: MasterClock): _Observable.Observable<number>
+	return Rx.of(0) :: any
 end
 
 --[=[
 	Returns true if the manager has synced with the server
 	@return boolean
 ]=]
-function MasterClock:IsSynced(): boolean
+function MasterClock.IsSynced(_self: MasterClock): boolean
 	return true
 end
 
@@ -81,25 +94,25 @@ end
 	Returns estimated ping in seconds
 	@return number
 ]=]
-function MasterClock:GetPing(): number
-	return self._offset
+function MasterClock.GetPing(_self: MasterClock): number
+	return 0
 end
 
 --[=[
 	Returns the sycncronized time
 	@return number
 ]=]
-function MasterClock:GetTime(): number
+function MasterClock.GetTime(_self: MasterClock): number
 	return tick()
 end
 
-function MasterClock:_forceSync()
+function MasterClock._forceSync(self: MasterClock): ()
 	-- start the sync process with all slave clocks.
 	local timeOne = self:GetTime()
 	self._remoteEvent:FireAllClients(timeOne)
 end
 
-function MasterClock:_handleDelayRequest(timeThree: number)
+function MasterClock._handleDelayRequest(self: MasterClock, timeThree: number): number
 	-- Client sends back message to get the SM_Difference.
 	-- returns slaveMasterDifference
 	local timeFour = self:GetTime()

package/src/Shared/Clocks/SlaveClock.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Slave clock on the client
 	@class SlaveClock
@@ -7,12 +8,30 @@ local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
 local ValueObject = require("ValueObject")
+local _Observable = require("Observable")
 
 local SlaveClock = setmetatable({}, BaseObject)
 SlaveClock.__index = SlaveClock
 SlaveClock.ClassName = "SlaveClock"
 SlaveClock._offset = -1 -- Set uncalculated values to -1
 
+export type ClockFunction = () -> number
+
+export type SlaveClock = typeof(setmetatable(
+	{} :: {
+		_remoteEvent: RemoteEvent,
+		_remoteFunction: RemoteFunction,
+		_clockFunction: ClockFunction,
+		_ping: ValueObject.ValueObject<number>,
+		_offset: number,
+		_pneWayDelay: number,
+		_syncedBindable: BindableEvent,
+
+		SyncedEvent: RBXScriptSignal,
+	},
+	{} :: typeof({ __index = SlaveClock })
+)) & BaseObject.BaseObject
+
 --[=[
 	Constructs a new SlaveClock
 
@@ -20,8 +39,8 @@ SlaveClock._offset = -1 -- Set uncalculated values to -1
 	@param remoteFunction RemoteFunction
 	@return SlaveClock
 ]=]
-function SlaveClock.new(remoteEvent: RemoteEvent, remoteFunction: RemoteFunction)
-	local self = setmetatable(BaseObject.new(), SlaveClock)
+function SlaveClock.new(remoteEvent: RemoteEvent, remoteFunction: RemoteFunction): SlaveClock
+	local self: SlaveClock = setmetatable(BaseObject.new() :: any, SlaveClock)
 
 	self._remoteEvent = remoteEvent or error("No remoteEvent")
 	self._remoteFunction = remoteFunction or error("No remoteFunction")
@@ -48,11 +67,11 @@ end
 
 	@return function
 ]=]
-function SlaveClock:GetClockFunction()
+function SlaveClock.GetClockFunction(self: SlaveClock): ClockFunction
 	return self._clockFunction
 end
 
-function SlaveClock:ObservePing()
+function SlaveClock.ObservePing(self: SlaveClock): _Observable.Observable<number>
 	return self._ping:Observe()
 end
 
@@ -61,7 +80,7 @@ end
 	@param syncedTime number
 	@return number
 ]=]
-function SlaveClock:TickToSyncedTime(syncedTime)
+function SlaveClock.TickToSyncedTime(self: SlaveClock, syncedTime: number): number
 	return syncedTime - self._offset
 end
 
@@ -69,7 +88,7 @@ end
 	Returns the sycncronized time
 	@return number
 ]=]
-function SlaveClock:GetTime(): number
+function SlaveClock.GetTime(self: SlaveClock): number
 	if not self:IsSynced() then
 		error("[SlaveClock.GetTime] - Slave clock is not yet synced")
 	end
@@ -81,11 +100,11 @@ end
 	Returns true if the manager has synced with the server
 	@return boolean
 ]=]
-function SlaveClock:IsSynced(): boolean
+function SlaveClock.IsSynced(self: SlaveClock): boolean
 	return self._offset ~= -1
 end
 
-function SlaveClock:_getLocalTime()
+function SlaveClock._getLocalTime(_self: SlaveClock)
 	-- NOTE: Do not change this without changing :TickToSyncedTime
 	return tick()
 end
@@ -94,11 +113,11 @@ end
 	Returns estimated ping in seconds
 	@return number
 ]=]
-function SlaveClock:GetPing(): number
+function SlaveClock.GetPing(self: SlaveClock): number
 	return self._ping.Value
 end
 
-function SlaveClock:_handleSyncEventAsync(timeOne)
+function SlaveClock._handleSyncEventAsync(self: SlaveClock, timeOne: number)
 	local timeTwo = self:_getLocalTime() -- We can't actually get hardware stuff, so we'll send T1 immediately.
 	local masterSlaveDifference = timeTwo - timeOne -- We have Offst + MS Delay
 
@@ -126,8 +145,8 @@ function SlaveClock:_handleSyncEventAsync(timeOne)
 		one_way_delay = (MSDelay + SMDelay) / 2
 	]]
 
-	local offset = (masterSlaveDifference - slaveMasterDifference)/2
-	local oneWayDelay = (masterSlaveDifference + slaveMasterDifference)/2
+	local offset = (masterSlaveDifference - slaveMasterDifference) / 2
+	local oneWayDelay = (masterSlaveDifference + slaveMasterDifference) / 2
 
 	self._offset = offset -- Estimated difference between server/client
 	self._pneWayDelay = oneWayDelay -- Estimated time for network events to send. (MSDelay/SMDelay)
@@ -136,7 +155,7 @@ function SlaveClock:_handleSyncEventAsync(timeOne)
 	self._syncedBindable:Fire()
 end
 
-function SlaveClock:_sendDelayRequestAsync(timeThree)
+function SlaveClock._sendDelayRequestAsync(self: SlaveClock, timeThree)
 	return self._remoteFunction:InvokeServer(timeThree)
 end
 

package/src/Shared/TimeSyncConstants.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class TimeSyncConstants
 ]=]
@@ -7,6 +8,6 @@ local require = require(script.Parent.loader).load(script)
 local Table = require("Table")
 
 return Table.readonly({
-	REMOTE_EVENT_NAME = "TimeSyncServiceRemoteEvent";
-	REMOTE_FUNCTION_NAME = "TimeSyncServiceRemoteFunction";
-})
+	REMOTE_EVENT_NAME = "TimeSyncServiceRemoteEvent",
+	REMOTE_FUNCTION_NAME = "TimeSyncServiceRemoteFunction",
+})

package/src/Shared/TimeSyncService.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Syncronizes time between the server and client. This creates a shared timestamp that can be used to reasonably time
 	events between the server and client.
@@ -21,18 +22,28 @@ local Rx = require("Rx")
 local SlaveClock = require("SlaveClock")
 local TimeSyncConstants = require("TimeSyncConstants")
 local TimeSyncUtils = require("TimeSyncUtils")
+local _Observable = require("Observable")
 
 local TimeSyncService = {}
 TimeSyncService.ServiceName = "TimeSyncService"
 
+export type SyncedClock = MasterClock.MasterClock | SlaveClock.SlaveClock
+
+export type TimeSyncService = typeof(setmetatable(
+	{} :: {
+		_clockPromise: Promise.Promise<SyncedClock>,
+		_maid: Maid.Maid,
+	},
+	{} :: typeof({ __index = TimeSyncService })
+))
+
 --[=[
 	Initializes the TimeSyncService
 ]=]
-function TimeSyncService:Init()
-	assert(not self._clockPromise, "TimeSyncService is already initialized!")
+function TimeSyncService.Init(self: TimeSyncService)
+	assert(not (self :: any)._clockPromise, "TimeSyncService is already initialized!")
 
 	self._maid = Maid.new()
-
 	self._clockPromise = self._maid:Add(Promise.new())
 
 	if not RunService:IsRunning() then
@@ -55,7 +66,7 @@ end
 
 	@return boolean
 ]=]
-function TimeSyncService:IsSynced(): boolean
+function TimeSyncService.IsSynced(self: TimeSyncService): boolean
 	if not RunService:IsRunning() then
 		return true
 	end
@@ -70,7 +81,7 @@ end
 	@yields
 	@return MasterClock | SlaveClock
 ]=]
-function TimeSyncService:WaitForSyncedClock()
+function TimeSyncService.WaitForSyncedClock(self: TimeSyncService): SyncedClock
 	if not RunService:IsRunning() then
 		return self:_buildMockClock()
 	end
@@ -84,7 +95,7 @@ end
 
 	@return MasterClock | SlaveClock | nil
 ]=]
-function TimeSyncService:GetSyncedClock()
+function TimeSyncService.GetSyncedClock(self: TimeSyncService): SyncedClock?
 	if not RunService:IsRunning() then
 		return self:_buildMockClock()
 	end
@@ -102,7 +113,7 @@ end
 
 	@return Promise<MasterClock | SlaveClock>
 ]=]
-function TimeSyncService:PromiseSyncedClock()
+function TimeSyncService.PromiseSyncedClock(self: TimeSyncService): Promise.Promise<SyncedClock>
 	if not RunService:IsRunning() then
 		return Promise.resolved(self:_buildMockClock())
 	end
@@ -111,11 +122,11 @@ function TimeSyncService:PromiseSyncedClock()
 	return Promise.resolved(self._clockPromise)
 end
 
-function TimeSyncService:ObserveSyncedClock()
-	return Rx.fromPromise(self:PromiseSyncedClock())
+function TimeSyncService.ObserveSyncedClock(self: TimeSyncService): _Observable.Observable<SyncedClock>
+	return Rx.fromPromise(self:PromiseSyncedClock()) :: any
 end
 
-function TimeSyncService:_buildMockClock()
+function TimeSyncService._buildMockClock(_self: TimeSyncService): any
 	local mock = {}
 
 	function mock.IsSynced(_self)
@@ -133,7 +144,7 @@ function TimeSyncService:_buildMockClock()
 	return mock
 end
 
-function TimeSyncService:_buildMasterClock()
+function TimeSyncService._buildMasterClock(self: TimeSyncService): MasterClock.MasterClock
 	local remoteEvent = GetRemoteEvent(TimeSyncConstants.REMOTE_EVENT_NAME)
 	local remoteFunction = GetRemoteFunction(TimeSyncConstants.REMOTE_FUNCTION_NAME)
 
@@ -142,21 +153,23 @@ function TimeSyncService:_buildMasterClock()
 	return clock
 end
 
-function TimeSyncService:_promiseSlaveClock()
-	return self._maid:GivePromise(PromiseUtils.all({
-		PromiseGetRemoteEvent(TimeSyncConstants.REMOTE_EVENT_NAME);
-		PromiseGetRemoteFunction(TimeSyncConstants.REMOTE_FUNCTION_NAME);
-	})):Then(function(remoteEvent, remoteFunction)
-		local clock = self._maid:Add(SlaveClock.new(remoteEvent, remoteFunction))
-
-		return TimeSyncUtils.promiseClockSynced(clock)
-	end)
+function TimeSyncService._promiseSlaveClock(self: TimeSyncService): Promise.Promise<SlaveClock.SlaveClock>
+	return self._maid
+		:GivePromise(PromiseUtils.all({
+			PromiseGetRemoteEvent(TimeSyncConstants.REMOTE_EVENT_NAME),
+			PromiseGetRemoteFunction(TimeSyncConstants.REMOTE_FUNCTION_NAME),
+		}))
+		:Then(function(remoteEvent, remoteFunction)
+			local clock = self._maid:Add(SlaveClock.new(remoteEvent, remoteFunction))
+
+			return TimeSyncUtils.promiseClockSynced(clock)
+		end)
 end
 
 --[=[
 	Cleans up the time syncronization service.
 ]=]
-function TimeSyncService:Destroy()
+function TimeSyncService.Destroy(self: TimeSyncService)
 	self._maid:DoCleaning()
 end
 

package/src/Shared/TimeSyncUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Helper functions for the TimeSyncService.
 	@class TimeSyncUtils