@quenty/loader 10.8.0 → 10.8.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.8.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@10.8.0...@quenty/loader@10.8.1) (2025-04-05)
+
+
+### Bug Fixes
+
+* Add types to packages ([2374fb2](https://github.com/Quenty/NevermoreEngine/commit/2374fb2b043cfbe0e9b507b3316eec46a4e353a0))
+
+
+
+
+
 # [10.8.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@10.7.1...@quenty/loader@10.8.0) (2025-02-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/loader",
-  "version": "10.8.0",
+  "version": "10.8.1",
   "description": "A simple module loader for Roblox",
   "keywords": [
     "Roblox",
@@ -26,5 +26,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "184a407d8d7366c39009444c3c9a7023cb176471"
+  "gitHead": "78c3ac0ab08dd18085b6e6e6e4f745e76ed99f68"
 }

package/src/Dependencies/DependencyUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Very inefficient search utility function to find dependencies
 	organized in node_modules structure.
@@ -20,18 +21,30 @@ local DependencyUtils = {}
 	@param requestedReplicationType ReplicationType
 	@return ModuleScript?
 ]=]
-function DependencyUtils.findDependency(requester, moduleName, requestedReplicationType)
+function DependencyUtils.findDependency(
+	requester,
+	moduleName: string,
+	requestedReplicationType: ReplicationType.ReplicationType
+): ModuleScript?
 	assert(typeof(requester) == "Instance", "Bad requester")
 	assert(type(moduleName) == "string", "Bad moduleName")
 	assert(ReplicationTypeUtils.isReplicationType(requestedReplicationType), "Bad requestedReplicationType")
 
 	for packageInst in DependencyUtils.iterPackages(requester) do
-		for module, replicationType in DependencyUtils.iterModules(packageInst, ReplicationType.SHARED) do
+		for module: ModuleScript, replicationType: ReplicationType.ReplicationType in
+			DependencyUtils.iterModules(packageInst, ReplicationType.SHARED)
+		do
 			if module.Name == moduleName then
 				if ReplicationTypeUtils.isAllowed(replicationType, requestedReplicationType) then
 					return module
 				else
-					error(string.format("[DependencyUtils] - %q is not allowed in %q", moduleName, requestedReplicationType))
+					error(
+						string.format(
+							"[DependencyUtils] - %q is not allowed in %q",
+							moduleName,
+							requestedReplicationType
+						)
+					)
 				end
 			end
 		end
@@ -40,20 +53,24 @@ function DependencyUtils.findDependency(requester, moduleName, requestedReplicat
 	return nil
 end
 
-function DependencyUtils.iterModules(packageInst, ancestorReplicationType)
+function DependencyUtils.iterModules(
+	packageInst: Instance,
+	ancestorReplicationType: ReplicationType.ReplicationType
+): () -> (ModuleScript, ReplicationType.ReplicationType)
 	assert(typeof(packageInst) == "Instance", "Bad packageInst")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
-	return coroutine.wrap(function()
+	return coroutine.wrap(function(): any
 		if packageInst:IsA("ModuleScript") then
 			coroutine.yield(packageInst, ancestorReplicationType)
 			return
 		end
 
 		-- Iterate over the package contents
-		for _, item in pairs(packageInst:GetChildren()) do
-			local itemName = item.Name
-			local itemReplicationType = ReplicationTypeUtils.getFolderReplicationType(itemName, ancestorReplicationType)
+		for _, item in packageInst:GetChildren() do
+			local itemName: string = item.Name
+			local itemReplicationType: ReplicationType.ReplicationType =
+				ReplicationTypeUtils.getFolderReplicationType(itemName, ancestorReplicationType)
 
 			if itemName ~= "node_modules" then
 				for result, resultReplicationType in DependencyUtils.iterModules(item, itemReplicationType) do
@@ -61,13 +78,15 @@ function DependencyUtils.iterModules(packageInst, ancestorReplicationType)
 				end
 			end
 		end
-	end)
+
+		return
+	end) :: any
 end
 
-function DependencyUtils.iterPackages(requester)
+function DependencyUtils.iterPackages(requester: Instance): () -> Instance
 	assert(typeof(requester) == "Instance", "Bad requester")
 
-	return coroutine.wrap(function()
+	return coroutine.wrap(function(): any
 		for nodeModules in DependencyUtils.iterNodeModulesUp(requester) do
 			coroutine.yield(nodeModules.Parent)
 
@@ -75,35 +94,39 @@ function DependencyUtils.iterPackages(requester)
 				coroutine.yield(packageInst)
 			end
 		end
+
+		return
 	end)
 end
 
-function DependencyUtils.iterNodeModulesUp(module)
+function DependencyUtils.iterNodeModulesUp(module: Instance): () -> Instance
 	assert(typeof(module) == "Instance", "Bad module")
 
-	return coroutine.wrap(function()
+	return coroutine.wrap(function(): any
 		local found = module:FindFirstChild("node_modules")
 		if found and found:IsA("Folder") then
 			coroutine.yield(found)
 		end
 
-		local current = module.Parent
+		local current: Instance? = module.Parent
 		while current do
 			found = current:FindFirstChild("node_modules")
 			if found and found:IsA("Folder") then
 				coroutine.yield(found)
 			end
-			current = current.Parent
+			current = current.Parent :: Instance?
 		end
+
+		return
 	end)
 end
 
-function DependencyUtils.iterPackagesInModuleModules(nodeModules)
-	return coroutine.wrap(function()
-		for _, item in pairs(nodeModules:GetChildren()) do
+function DependencyUtils.iterPackagesInModuleModules(nodeModules: Instance): () -> Instance
+	return coroutine.wrap(function(): any
+		for _, item in nodeModules:GetChildren() do
 			if item:IsA("Folder") then
 				if DependencyUtils.isPackageGroup(item.Name) then
-					for _, child in pairs(item:GetChildren()) do
+					for _, child in item:GetChildren() do
 						if child:IsA("ModuleScript") or child:IsA("Folder") then
 							coroutine.yield(child)
 						elseif child:IsA("ObjectValue") then
@@ -137,10 +160,12 @@ function DependencyUtils.iterPackagesInModuleModules(nodeModules)
 				end
 			end
 		end
+
+		return
 	end)
 end
 
-function DependencyUtils.isPackageGroup(itemName)
+function DependencyUtils.isPackageGroup(itemName: string): boolean
 	return string.sub(itemName, 1, 1) == "@"
 end
 

package/src/Dependencies/PackageTracker.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	For each package, track subdependent packages and packages
 
@@ -14,7 +15,29 @@ local PackageTracker = {}
 PackageTracker.ClassName = "PackageTracker"
 PackageTracker.__index = PackageTracker
 
-function PackageTracker.new(packageTrackerProvider, packageRoot)
+export type ModuleScriptInfo = {
+	moduleScript: ModuleScript,
+	replicationType: ReplicationType.ReplicationType,
+}
+
+export type PackageTrackerProvider = {
+	FindPackageTracker: (self: PackageTrackerProvider, instance: Instance) -> PackageTracker?,
+	AddPackageRoot: (self: PackageTrackerProvider, instance: Instance) -> PackageTracker,
+}
+
+export type PackageTracker = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_packageTrackerProvider: PackageTrackerProvider,
+		_packageRoot: Instance,
+		_subpackagesMap: { [string]: Instance },
+		_subpackagesTrackerList: { PackageTracker },
+		_packageModuleScriptMap: { [string]: ModuleScriptInfo },
+	},
+	PackageTracker
+))
+
+function PackageTracker.new(packageTrackerProvider: PackageTrackerProvider, packageRoot: Instance): PackageTracker
 	assert(packageTrackerProvider, "No packageTrackerProvider")
 	assert(typeof(packageRoot) == "Instance", "Bad packageRoot")
 
@@ -24,23 +47,33 @@ function PackageTracker.new(packageTrackerProvider, packageRoot)
 	self._packageTrackerProvider = assert(packageTrackerProvider, "No packageTrackerProvider")
 	self._packageRoot = assert(packageRoot, "No packageRoot")
 
-	self._subpackagesMap = {}
-	self._subpackagesTrackerList = {}
-	self._packageModuleScriptMap = {}
+	self._subpackagesMap = {} :: { [string]: Instance }
+	self._subpackagesTrackerList = {} :: { PackageTracker }
+	self._packageModuleScriptMap = {} :: { [string]: ModuleScriptInfo }
 
 	return self
 end
 
-function PackageTracker:StartTracking()
+function PackageTracker.StartTracking(self: PackageTracker)
+	local moduleScript: ModuleScript? = nil
 	if self._packageRoot:IsA("ModuleScript") then
+		moduleScript = self._packageRoot
+	end
+
+	if moduleScript ~= nil then
 		-- Module script children don't get to be observed
-		self._maid:GiveTask(self:_trackModuleScript(self._packageRoot, ReplicationType.SHARED))
+		self._maid:GiveTask(self:_trackModuleScript(moduleScript, ReplicationType.SHARED))
 	else
-		self._maid:GiveTask(self:_trackChildren(self._packageRoot, ReplicationType.SHARED))
+		local root = self._packageRoot :: Instance
+		self._maid:GiveTask(self:_trackChildren(root, ReplicationType.SHARED))
 	end
 end
 
-function PackageTracker:ResolveDependency(request, replicationType)
+function PackageTracker.ResolveDependency(
+	self: PackageTracker,
+	request: string,
+	replicationType: ReplicationType.ReplicationType
+): ModuleScript?
 	local packageModuleScript = self:FindPackageModuleScript(request, replicationType)
 	if packageModuleScript then
 		return packageModuleScript
@@ -59,7 +92,11 @@ function PackageTracker:ResolveDependency(request, replicationType)
 	return nil
 end
 
-function PackageTracker:FindImplicitParentModuleScript(request, replicationType)
+function PackageTracker.FindImplicitParentModuleScript(
+	self: PackageTracker,
+	request: string,
+	replicationType: ReplicationType.ReplicationType
+): ModuleScript?
 	assert(type(request) == "string", "Bad request")
 	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
 
@@ -80,10 +117,14 @@ function PackageTracker:FindImplicitParentModuleScript(request, replicationType)
 		return subpackageModuleScript
 	end
 
-	return parentProvider:FindImplicitParentModuleScript(request, replicationType)
+	return parentProvider:FindImplicitParentModuleScript(request, replicationType) :: ModuleScript?
 end
 
-function PackageTracker:FindPackageModuleScript(moduleScriptName, replicationType)
+function PackageTracker.FindPackageModuleScript(
+	self: PackageTracker,
+	moduleScriptName: string,
+	replicationType: ReplicationType.ReplicationType
+): ModuleScript?
 	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
 	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
 
@@ -100,11 +141,15 @@ function PackageTracker:FindPackageModuleScript(moduleScriptName, replicationTyp
 	end
 end
 
-function PackageTracker:FindSubpackageModuleScript(moduleScriptName, replicationType)
+function PackageTracker.FindSubpackageModuleScript(
+	self: PackageTracker,
+	moduleScriptName: string,
+	replicationType: ReplicationType.ReplicationType
+): ModuleScript?
 	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
 	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
 
-	for _, packageTracker in pairs(self._subpackagesTrackerList) do
+	for _, packageTracker in self._subpackagesTrackerList do
 		local found = packageTracker._packageModuleScriptMap[moduleScriptName]
 		if found then
 			if ReplicationTypeUtils.isAllowed(found.replicationType, replicationType) then
@@ -118,16 +163,22 @@ function PackageTracker:FindSubpackageModuleScript(moduleScriptName, replication
 	return nil
 end
 
-function PackageTracker:_trackChildrenAndReplicationType(parent, ancestorReplicationType)
+function PackageTracker._trackChildrenAndReplicationType(
+	self: PackageTracker,
+	parent: Instance,
+	ancestorReplicationType: ReplicationType.ReplicationType
+)
 	assert(typeof(parent) == "Instance", "Bad parent")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
 	local maid = Maid.new()
 
-	local lastReplicationType = ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
+	local lastReplicationType: ReplicationType.ReplicationType =
+		ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
 
 	maid:GiveTask(parent:GetPropertyChangedSignal("Name"):Connect(function()
-		local newReplicationType = ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
+		local newReplicationType: ReplicationType.ReplicationType =
+			ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
 		if newReplicationType ~= lastReplicationType then
 			maid._current = self:_trackChildren(parent, newReplicationType)
 			lastReplicationType = newReplicationType
@@ -139,7 +190,11 @@ function PackageTracker:_trackChildrenAndReplicationType(parent, ancestorReplica
 	return maid
 end
 
-function PackageTracker:_trackChildren(parent, ancestorReplicationType)
+function PackageTracker._trackChildren(
+	self: PackageTracker,
+	parent: Instance,
+	ancestorReplicationType: ReplicationType.ReplicationType
+): Maid.Maid
 	assert(typeof(parent) == "Instance", "Bad parent")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
@@ -149,16 +204,21 @@ function PackageTracker:_trackChildren(parent, ancestorReplicationType)
 		self:_handleChildAdded(maid, child, ancestorReplicationType)
 	end))
 	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
-		self:_handleChildRemoved(maid, child, ancestorReplicationType)
+		self:_handleChildRemoved(maid, child)
 	end))
-	for _, child in pairs(parent:GetChildren()) do
+	for _, child in parent:GetChildren() do
 		self:_handleChildAdded(maid, child, ancestorReplicationType)
 	end
 
 	return maid
 end
 
-function PackageTracker:_handleChildAdded(parentMaid, child, ancestorReplicationType)
+function PackageTracker._handleChildAdded(
+	self: PackageTracker,
+	parentMaid: Maid.Maid,
+	child: Instance,
+	ancestorReplicationType: ReplicationType.ReplicationType
+)
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
@@ -170,15 +230,18 @@ function PackageTracker:_handleChildAdded(parentMaid, child, ancestorReplication
 	end
 end
 
-function PackageTracker:_handleChildRemoved(parentMaid, child)
+function PackageTracker._handleChildRemoved(_self: PackageTracker, parentMaid: Maid.Maid, child: Instance)
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
 
 	parentMaid[child] = nil
 end
 
-
-function PackageTracker:_trackFolder(child, ancestorReplicationType)
+function PackageTracker._trackFolder(
+	self: PackageTracker,
+	child: Instance,
+	ancestorReplicationType: ReplicationType.ReplicationType
+)
 	assert(typeof(child) == "Instance", "Bad child")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
@@ -201,12 +264,14 @@ function PackageTracker:_trackFolder(child, ancestorReplicationType)
 	return maid
 end
 
-
-function PackageTracker:_trackModuleScript(child, ancestorReplicationType)
+function PackageTracker._trackModuleScript(
+	self: PackageTracker,
+	child: ModuleScript,
+	ancestorReplicationType: ReplicationType.ReplicationType
+): Maid.Maid
 	assert(typeof(child) == "Instance", "Bad child")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
-
 	local maid = Maid.new()
 
 	local function update()
@@ -225,7 +290,12 @@ function PackageTracker:_trackModuleScript(child, ancestorReplicationType)
 	return maid
 end
 
-function PackageTracker:_storeModuleScript(moduleScriptName, child, ancestorReplicationType)
+function PackageTracker._storeModuleScript(
+	self: PackageTracker,
+	moduleScriptName: string,
+	child: ModuleScript,
+	ancestorReplicationType: ReplicationType.ReplicationType
+): () -> ()
 	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
 	assert(typeof(child) == "Instance", "Bad child")
 	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
@@ -234,9 +304,9 @@ function PackageTracker:_storeModuleScript(moduleScriptName, child, ancestorRepl
 		warn(string.format("[PackageTracker] - Overwriting moduleScript with name %q", moduleScriptName))
 	end
 
-	local data = {
-		moduleScript = child;
-		replicationType = ancestorReplicationType;
+	local data: ModuleScriptInfo = {
+		moduleScript = child,
+		replicationType = ancestorReplicationType,
 	}
 	self._packageModuleScriptMap[moduleScriptName] = data
 
@@ -247,7 +317,7 @@ function PackageTracker:_storeModuleScript(moduleScriptName, child, ancestorRepl
 	end
 end
 
-function PackageTracker:_trackMainNodeModuleFolder(parent)
+function PackageTracker._trackMainNodeModuleFolder(self: PackageTracker, parent: Instance): Maid.Maid
 	local maid = Maid.new()
 
 	maid:GiveTask(parent.ChildAdded:Connect(function(child)
@@ -256,15 +326,14 @@ function PackageTracker:_trackMainNodeModuleFolder(parent)
 	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
 		self:_handleNodeModulesChildRemoved(maid, child)
 	end))
-	for _, child in pairs(parent:GetChildren()) do
+	for _, child in parent:GetChildren() do
 		self:_handleNodeModulesChildAdded(maid, child)
 	end
 
 	return maid
 end
 
-
-function PackageTracker:_handleNodeModulesChildAdded(parentMaid, child)
+function PackageTracker._handleNodeModulesChildAdded(self: PackageTracker, parentMaid: Maid.Maid, child: Instance)
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
 
@@ -278,19 +347,19 @@ function PackageTracker:_handleNodeModulesChildAdded(parentMaid, child)
 	end
 end
 
-function PackageTracker:_handleNodeModulesChildRemoved(parentMaid, child)
+function PackageTracker._handleNodeModulesChildRemoved(_self: PackageTracker, parentMaid: Maid.Maid, child: Instance)
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
 
 	parentMaid[child] = nil
 end
 
-function PackageTracker:_trackNodeModulesChildFolder(child)
+function PackageTracker._trackNodeModulesChildFolder(self: PackageTracker, child: Instance): Maid.Maid
 	assert(typeof(child) == "Instance", "Bad child")
 
 	local maid = Maid.new()
 
-	local function update()
+	local function update(): Maid.MaidTask
 		local childName = child.Name
 
 		-- like @quenty
@@ -310,7 +379,7 @@ function PackageTracker:_trackNodeModulesChildFolder(child)
 	return maid
 end
 
-function PackageTracker:_trackNodeModulesObjectValue(objectValue)
+function PackageTracker._trackNodeModulesObjectValue(self: PackageTracker, objectValue: ObjectValue): Maid.Maid
 	assert(typeof(objectValue) == "Instance", "Bad objectValue")
 
 	local maid = Maid.new()
@@ -327,7 +396,7 @@ function PackageTracker:_trackNodeModulesObjectValue(objectValue)
 	return maid
 end
 
-function PackageTracker:_trackScopedChildFolder(scopeName, parent)
+function PackageTracker._trackScopedChildFolder(self: PackageTracker, scopeName: string, parent: Instance): Maid.Maid
 	assert(type(scopeName) == "string", "Bad scopeName")
 	assert(typeof(parent) == "Instance", "Bad parent")
 
@@ -339,14 +408,19 @@ function PackageTracker:_trackScopedChildFolder(scopeName, parent)
 	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
 		self:_handleScopedModulesChildRemoved(maid, child)
 	end))
-	for _, child in pairs(parent:GetChildren()) do
+	for _, child in parent:GetChildren() do
 		self:_handleScopedModulesChildAdded(scopeName, maid, child)
 	end
 
 	return maid
 end
 
-function PackageTracker:_handleScopedModulesChildAdded(scopeName, parentMaid, child)
+function PackageTracker._handleScopedModulesChildAdded(
+	self: PackageTracker,
+	scopeName: string,
+	parentMaid: Maid.Maid,
+	child: Instance
+)
 	assert(type(scopeName) == "string", "Bad scopeName")
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
@@ -358,7 +432,11 @@ function PackageTracker:_handleScopedModulesChildAdded(scopeName, parentMaid, ch
 	end
 end
 
-function PackageTracker:_trackScopedNodeModulesObjectValue(scopeName, objectValue)
+function PackageTracker._trackScopedNodeModulesObjectValue(
+	self: PackageTracker,
+	scopeName: string,
+	objectValue: ObjectValue
+)
 	assert(type(scopeName) == "string", "Bad scopeName")
 	assert(typeof(objectValue) == "Instance", "Bad objectValue")
 
@@ -376,14 +454,14 @@ function PackageTracker:_trackScopedNodeModulesObjectValue(scopeName, objectValu
 	return maid
 end
 
-function PackageTracker:_handleScopedModulesChildRemoved(parentMaid, child)
+function PackageTracker._handleScopedModulesChildRemoved(_self: PackageTracker, parentMaid: Maid.Maid, child: Instance)
 	assert(Maid.isMaid(parentMaid), "Bad maid")
 	assert(typeof(child) == "Instance", "Bad child")
 
 	parentMaid[child] = nil
 end
 
-function PackageTracker:_trackAddScopedPackage(scopeName, child)
+function PackageTracker._trackAddScopedPackage(self: PackageTracker, scopeName: string, child: Instance)
 	assert(type(scopeName) == "string", "Bad scopeName")
 	assert(typeof(child) == "Instance", "Bad child")
 
@@ -398,7 +476,7 @@ function PackageTracker:_trackAddScopedPackage(scopeName, child)
 	return maid
 end
 
-function PackageTracker:_trackAddPackage(child)
+function PackageTracker._trackAddPackage(self: PackageTracker, child: Instance)
 	assert(typeof(child) == "Instance", "Bad child")
 
 	local maid = Maid.new()
@@ -412,7 +490,11 @@ function PackageTracker:_trackAddPackage(child)
 	return maid
 end
 
-function PackageTracker:_tryStorePackage(fullPackageName, packageInst)
+function PackageTracker._tryStorePackage(
+	self: PackageTracker,
+	fullPackageName: string,
+	packageInst: Instance?
+): (() -> ())?
 	assert(type(fullPackageName) == "string", "Bad fullPackageName")
 
 	if not packageInst then
@@ -436,7 +518,7 @@ function PackageTracker:_tryStorePackage(fullPackageName, packageInst)
 	end
 end
 
-function PackageTracker:Destroy()
+function PackageTracker.Destroy(self: PackageTracker)
 	self._maid:DoCleaning()
 end
 

package/src/Dependencies/PackageTrackerProvider.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class PackageTrackerProvider
 ]=]
@@ -11,7 +12,16 @@ local PackageTrackerProvider = {}
 PackageTrackerProvider.ClassName = "PackageTrackerProvider"
 PackageTrackerProvider.__index = PackageTrackerProvider
 
-function PackageTrackerProvider.new()
+export type PackageTrackerProvider = typeof(setmetatable(
+	{} :: {
+		_packageTrackersRoots: { [Instance]: PackageTracker.PackageTracker },
+		_maid: Maid.Maid,
+		_trackCount: number,
+	},
+	PackageTrackerProvider
+))
+
+function PackageTrackerProvider.new(): PackageTrackerProvider
 	local self = setmetatable({}, PackageTrackerProvider)
 
 	self._maid = Maid.new()
@@ -21,28 +31,37 @@ function PackageTrackerProvider.new()
 	return self
 end
 
-function PackageTrackerProvider:AddPackageRoot(instance)
+function PackageTrackerProvider.AddPackageRoot(
+	self: PackageTrackerProvider,
+	instance: Instance
+): PackageTracker.PackageTracker
 	assert(typeof(instance) == "Instance", "Bad instance")
 
 	if self._packageTrackersRoots[instance] then
 		return self._packageTrackersRoots[instance]
 	end
 
-	self._trackCount = self._trackCount + 1
+	self._trackCount += 1
 
 	local maid = Maid.new()
 
-	self._packageTrackersRoots[instance] = maid:Add(PackageTracker.new(self, instance))
+	local packageTracker = PackageTracker.new(self :: any, instance)
+	maid:GiveTask(packageTracker)
+
+	self._packageTrackersRoots[instance] = packageTracker
 	self._maid[instance] = maid
 
-	self._packageTrackersRoots[instance]:StartTracking()
+	packageTracker:StartTracking()
 
 	-- TODO: Provide cleanup mechanism
 
 	return self._packageTrackersRoots[instance]
 end
 
-function PackageTrackerProvider:FindPackageTracker(instance)
+function PackageTrackerProvider.FindPackageTracker(
+	self: PackageTrackerProvider,
+	instance: Instance
+): PackageTracker.PackageTracker?
 	assert(typeof(instance) == "Instance", "Bad instance")
 
 	local current = instance
@@ -51,13 +70,13 @@ function PackageTrackerProvider:FindPackageTracker(instance)
 			return self._packageTrackersRoots[current]
 		end
 
-		current = current.Parent
+		current = current.Parent :: Instance
 	end
 
 	return nil
 end
 
-function PackageTrackerProvider:Destroy()
+function PackageTrackerProvider.Destroy(self: PackageTrackerProvider)
 	self._maid:DoCleaning()
 end
 

package/src/LoaderLink/LoaderLink.lua

@@ -1,3 +1,4 @@
+--!nocheck
 --[=[
 	This class is linking to the Nevermore loader.
 
@@ -13,7 +14,7 @@
 	@class LoaderLink
 ]=]
 
-local function waitForValue(objectValue)
+local function waitForValue(objectValue: ObjectValue): Instance
 	local value = objectValue.Value
 	if value then
 		return value