@quenty/loader 5.0.1 → 5.0.2-canary.d7ea97f.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.0.2-canary.d7ea97f.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@5.0.1...@quenty/loader@5.0.2-canary.d7ea97f.0) (2022-09-27)
+
+
+### Bug Fixes
+
+* Add untested hot reloading loader replication logic ([384a8f1](https://github.com/Quenty/NevermoreEngine/commit/384a8f166c781a6d67485d8cee1269915ba2a5ad))
+
+
+### Features
+
+* Support hiding server code behind the camera ([afc0e0a](https://github.com/Quenty/NevermoreEngine/commit/afc0e0a35592f68397d6db8108e7955b737ecfe0))
+
+
+
+
+
 ## [5.0.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@5.0.0...@quenty/loader@5.0.1) (2022-08-16)
 
 **Note:** Version bump only for package @quenty/loader

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/loader",
-  "version": "5.0.1",
+  "version": "5.0.2-canary.d7ea97f.0",
   "description": "A simple module loader for Roblox",
   "keywords": [
     "Roblox",
@@ -26,5 +26,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "340ac324c03fb3b844bbbe7ca57ee88874a724c9"
+  "gitHead": "d7ea97f676c9246d2350b7582d5ab3ff6c44e42f"
 }

package/src/LoaderUtils.lua

@@ -87,7 +87,7 @@ function LoaderUtils.isPackage(folder)
 	assert(typeof(folder) == "Instance", "Bad instance")
 
 	for _, item in pairs(folder:GetChildren()) do
-		if item:IsA("Folder") then
+		if item:IsA("Folder") or item:IsA("Camera") then
 			if item.Name == "Server"
 				or item.Name == "Client"
 				or item.Name == "Shared"
@@ -126,7 +126,7 @@ function LoaderUtils.discoverTopLevelPackages(packages, instance)
 	else
 		-- Loop through all folders
 		for _, item in pairs(instance:GetChildren()) do
-			if item:IsA("Folder") then
+			if item:IsA("Folder") or item:IsA("Camera") then
 				LoaderUtils.discoverTopLevelPackages(packages, item)
 			elseif item:IsA("ObjectValue") then
 				local linkedValue = item.Value

package/src/PackageInfoUtils.lua

@@ -212,7 +212,7 @@ function PackageInfoUtils.fillExplicitPackageDependencySet(
 	assert(defaultReplicationType, "No defaultReplicationType")
 
 	for _, item in pairs(packageFolder:GetChildren()) do
-		if item:IsA("Folder") and item.Name == ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
+		if (item:IsA("Folder") or item:IsA("Camera")) and item.Name == ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
 			local packageInfoList = PackageInfoUtils.getPackageInfoListFromDependencyFolder(
 				item,
 				packageInfoMap,

package/src/ScriptInfoUtils.lua

@@ -54,12 +54,12 @@ function ScriptInfoUtils.populateScriptInfoLookup(instance, scriptInfoLookup, la
 	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
 	assert(type(lastReplicationMode) == "string", "Bad lastReplicationMode")
 
-	if instance:IsA("Folder") then
+	if instance:IsA("Folder") or instance:IsA("Camera") then
 		local replicationMode = ScriptInfoUtils.getFolderReplicationMode(instance.Name, lastReplicationMode)
 		if replicationMode ~= ScriptInfoUtils.ModuleReplicationTypes.IGNORE then
 			for _, item in pairs(instance:GetChildren()) do
 				if not BounceTemplateUtils.isBounceTemplate(item) then
-					if item:IsA("Folder") then
+					if item:IsA("Folder") or item:IsA("Camera") then
 						ScriptInfoUtils.populateScriptInfoLookup(item, scriptInfoLookup, replicationMode)
 					elseif item:IsA("ModuleScript") then
 						ScriptInfoUtils.addToInfoMap(scriptInfoLookup,

package/src/StaticLegacyLoader.lua

@@ -109,7 +109,7 @@ function StaticLegacyLoader:_getPackageFolderLookup(instance)
 			warn("[StaticLegacyLoader] - Bad link in packageFolder")
 			return {}
 		end
-	elseif instance:IsA("Folder") then
+	elseif instance:IsA("Folder") or instance:IsA("Camera") then
 		return self:_getOrCreateLookup(instance)
 	elseif instance:IsA("ModuleScript") then
 		return self:_getOrCreateLookup(instance)
@@ -136,7 +136,7 @@ function StaticLegacyLoader:_getOrCreateLookup(packageFolderOrModuleScript)
 end
 
 function StaticLegacyLoader:_buildLookup(lookup, instance)
-	if instance:IsA("Folder") then
+	if instance:IsA("Folder") or instance:IsA("Camera") then
 		if instance.Name ~= ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
 			for _, item in pairs(instance:GetChildren()) do
 				self:_buildLookup(lookup, item)

package/src2/Bounce/BounceTemplate.lua

@@ -0,0 +1,17 @@
+--[=[
+	Bounces the current named script to the expected version of this module
+
+	@private
+	@class BounceTemplate
+]=]
+
+local function waitForValue(objectValue)
+	local value = objectValue.Value
+	if value then
+		return value
+	end
+
+	return objectValue.Changed:Wait()
+end
+
+return require(waitForValue(script:WaitForChild("BounceTarget")))

package/src2/Bounce/BounceTemplateUtils.lua

@@ -0,0 +1,51 @@
+--[=[
+	@class BounceTemplateUtils
+	@private
+]=]
+
+local BounceTemplate = script.Parent.BounceTemplate
+
+local BounceTemplateUtils = {}
+
+function BounceTemplateUtils.isBounceTemplate(instance)
+	return instance:GetAttribute("IsBounceTemplate", true) == true
+end
+
+function BounceTemplateUtils.getTarget(instance)
+	if not BounceTemplateUtils.isBounceTemplate(instance) then
+		return nil
+	end
+
+	if instance:IsA("ObjectValue") then
+		return instance.Value
+	else
+		local found = instance:FindFirstChild("BounceTarget")
+		if found then
+			return found.Value
+		else
+			warn("[BounceTemplateUtils.getTarget] - Bounce template without BounceTarget")
+			return nil
+		end
+	end
+end
+
+function BounceTemplateUtils.create(target, linkName)
+	assert(typeof(target) == "Instance", "Bad target")
+	assert(type(linkName) == "string", "Bad linkName")
+
+
+	local copy = BounceTemplate:Clone()
+	copy:SetAttribute("IsBounceTemplate", true)
+	copy.Name = linkName
+	copy.Archivable = false
+
+	local objectValue = Instance.new("ObjectValue")
+	objectValue.Name = "BounceTarget"
+	objectValue.Value = target
+	objectValue.Parent = copy
+	objectValue.Archivable = false
+
+	return copy
+end
+
+return BounceTemplateUtils

package/src2/Dependencies/DependencyUtils.lua

@@ -0,0 +1,133 @@
+--[=[
+	Very inefficient search utility function to find dependencies
+	organized in node_modules structure.
+
+	@class DependencyUtils
+]=]
+
+local DependencyUtils = {}
+
+--[=[
+	Iteratively searches for a dependency based upon packages and current modules using the node_modules
+	dependency resolution algorithm.
+
+	@param requester Instance
+	@param moduleName string
+	@return ModuleScript?
+]=]
+function DependencyUtils.findDependency(requester, moduleName)
+	assert(typeof(requester) == "Instance", "Bad requester")
+	assert(type(moduleName) == "string", "Bad moduleName")
+
+	for packageInst in DependencyUtils.iterPackages(requester) do
+		for module in DependencyUtils.iterModules(packageInst) do
+			if module.Name == moduleName then
+				return module
+			end
+		end
+	end
+
+	return nil
+end
+
+function DependencyUtils.iterModules(packageInst)
+	assert(typeof(packageInst) == "Instance", "Bad packageInst")
+
+	return coroutine.wrap(function()
+		if packageInst:IsA("ModuleScript") then
+			coroutine.yield(packageInst)
+			return
+		end
+
+		-- Iterate over the package contents
+		for _, item in pairs(packageInst:GetChildren()) do
+			if item.Name ~= "node_modules" then
+				for result in DependencyUtils.iterModules(item) do
+					coroutine.yield(result)
+				end
+			end
+		end
+	end)
+end
+
+function DependencyUtils.iterPackages(requester)
+	assert(typeof(requester) == "Instance", "Bad requester")
+
+	return coroutine.wrap(function()
+		for nodeModules in DependencyUtils.iterNodeModules(requester) do
+			coroutine.yield(nodeModules.Parent)
+
+			for packageInst in DependencyUtils.iterPackagesInModuleModules(nodeModules) do
+				coroutine.yield(packageInst)
+			end
+		end
+	end)
+end
+
+function DependencyUtils.iterNodeModules(module)
+	assert(typeof(module) == "Instance", "Bad module")
+
+	return coroutine.wrap(function()
+		local found = module:FindFirstChild("node_modules")
+		if found and found:IsA("Folder") then
+			coroutine.yield(found)
+		end
+
+		local current = module.Parent
+		while current do
+			found = current:FindFirstChild("node_modules")
+			if found and found:IsA("Folder") then
+				coroutine.yield(found)
+			end
+			current = current.Parent
+		end
+	end)
+end
+
+function DependencyUtils.iterPackagesInModuleModules(nodeModules)
+	return coroutine.wrap(function()
+		for _, item in pairs(nodeModules:GetChildren()) do
+			if item:IsA("Folder") then
+				if DependencyUtils.isPackageGroup(item.Name) then
+					for _, child in pairs(item:GetChildren()) do
+						if child:IsA("ModuleScript") or child:IsA("Folder") then
+							coroutine.yield(child)
+						elseif child:IsA("ObjectValue") then
+							local linked = child.Value
+							if linked then
+								if linked:IsA("ModuleScript") or linked:IsA("Folder") then
+									coroutine.yield(linked)
+								else
+									warn("Bad link value type")
+								end
+							else
+								warn("Nothing linked")
+							end
+						end
+					end
+				else
+					coroutine.yield(item)
+				end
+			elseif item:IsA("ModuleScript") then
+				coroutine.yield(item)
+			elseif item:IsA("ObjectValue") then
+				local linked = item.Value
+				if linked then
+					if linked:IsA("ModuleScript") or linked:IsA("Folder") then
+						coroutine.yield(linked)
+					else
+						warn("Bad link value type")
+					end
+				else
+					warn("Nothing linked")
+				end
+			end
+		end
+	end)
+end
+
+function DependencyUtils.isPackageGroup(itemName)
+	return itemName:sub(1, 1) == "@"
+end
+
+return DependencyUtils

package/src2/Loader/LoaderAdder.lua

@@ -0,0 +1,181 @@
+--[=[
+	Adds the loader instance so script.Parent.loader works.
+	@class LoaderAdder
+]=]
+
+local loader = script.Parent.Parent
+local BounceTemplateUtils = require(script.Parent.Parent.Bounce.BounceTemplateUtils)
+local ReplicatorReferences = require(script.Parent.Parent.Replication.ReplicatorReferences)
+local Maid = require(script.Parent.Parent.Maid)
+local ReplicationType = require(script.Parent.Parent.Replication.ReplicationType)
+local ReplicationTypeUtils = require(script.Parent.Parent.Replication.ReplicationTypeUtils)
+
+local LoaderAdder = {}
+LoaderAdder.ClassName = "LoaderAdder"
+LoaderAdder.__index = LoaderAdder
+
+function LoaderAdder.new(references, root, replicationType)
+	local self = setmetatable({}, LoaderAdder)
+
+	assert(typeof(root) == "Instance", "Bad root")
+	assert(ReplicatorReferences.isReplicatorReferences(references), "Bad references")
+	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
+
+	self._references = references
+	self._root = root
+	self._replicationType = replicationType
+
+	self._maid = Maid.new()
+
+	self._needsLoaderCount = Instance.new("IntValue")
+	self._needsLoaderCount.Value = 0
+	self._maid:GiveTask(self._needsLoaderCount)
+
+	self._hasLoaderCount = Instance.new("IntValue")
+	self._hasLoaderCount.Value = 0
+	self._maid:GiveTask(self._hasLoaderCount)
+
+	self._needsLoader = Instance.new("BoolValue")
+	self._needsLoader.Value = false
+	self._maid:GiveTask(self._needsLoader)
+
+	self._maid:GiveTask(self._needsLoaderCount.Changed:Connect(function()
+		self:_updateNeedsLoader()
+	end))
+	self._maid:GiveTask(self._hasLoaderCount.Changed:Connect(function()
+		self:_updateNeedsLoader()
+	end))
+
+	self._maid:GiveTask(self._needsLoader.Changed:Connect(function()
+		if self._needsLoader.Value then
+			self._maid._loader = self:_renderLoader()
+		else
+			self._maid._loader = nil
+		end
+	end))
+
+	self:_updateNeedsLoader()
+
+	if self._replicationType ~= ReplicationType.SERVER then
+		self._maid:GiveTask(self._references:ObserveReferenceChanged(loader, function(value)
+			if value and value ~= loader then
+				self._maid._trackFakeLoader = self:_trackLoaderReference(value)
+			else
+				self._maid._trackFakeLoader = nil
+			end
+		end))
+	end
+	self._maid:GiveTask(self:_trackLoaderReference(loader))
+
+	-- Do actual setup
+	self._maid:GiveTask(root.ChildAdded:Connect(function(child)
+		self:_handleChildAdded(child)
+	end))
+	self._maid:GiveTask(root.ChildRemoved:Connect(function(child)
+		self:_handleChildRemoved(child)
+	end))
+	for _, child in pairs(root:GetChildren()) do
+		self:_handleChildAdded(child)
+	end
+
+	return self
+end
+
+function LoaderAdder:_updateNeedsLoader()
+	self._needsLoader.Value = (self._needsLoaderCount.Value > 0) and self._hasLoaderCount.Value <= 0
+end
+
+function LoaderAdder:_handleChildRemoved(child)
+	self._maid[child] = nil
+end
+
+function LoaderAdder:_handleChildAdded(child)
+	assert(typeof(child) == "Instance", "Bad child")
+
+	local maid = Maid.new()
+
+
+	if child:IsA("ModuleScript") then
+		self:_setupNeedsLoaderCountAdd(maid, 1)
+	else
+		-- TODO: Maybe add to children with node_modules explicitly in its list.
+		local loaderAdder = LoaderAdder.new(self._references, child, self._replicationType)
+		maid:GiveTask(loaderAdder)
+	end
+
+	self._maid[child] = maid
+end
+
+function LoaderAdder:_renderLoader()
+	local maid = Maid.new()
+
+	if self._replicationType == ReplicationType.SERVER then
+		maid._current = self:_doLoaderRender(loader)
+	else
+		maid:GiveTask(self._references:ObserveReferenceChanged(loader, function(value)
+			if value then
+				maid._current = self:_doLoaderRender(value)
+			else
+				maid._current = nil
+			end
+		end))
+	end
+
+	return maid
+end
+
+function LoaderAdder:_doLoaderRender(value)
+	local loaderLink = BounceTemplateUtils.create(value, loader.Name)
+	loaderLink.Parent = self._root
+
+	return loaderLink
+end
+
+function LoaderAdder:_setupNeedsLoaderCountAdd(maid, amount)
+	assert(Maid.isMaid(maid), "Bad maid")
+	assert(type(amount) == "number", "Bad amount")
+
+	self._needsLoaderCount.Value = self._needsLoaderCount.Value + amount
+	maid:GiveTask(function()
+		self._needsLoaderCount.Value = self._needsLoaderCount.Value - amount
+	end)
+end
+
+function LoaderAdder:_addToLoaderCount(amount)
+	assert(type(amount) == "number", "Bad amount")
+
+	self._hasLoaderCount.Value = self._hasLoaderCount.Value + amount
+	return function()
+		self._hasLoaderCount.Value = self._hasLoaderCount.Value - amount
+	end
+end
+
+function LoaderAdder:_trackLoaderReference(ref)
+	local maid = Maid.new()
+
+	-- TODO: Maybe handle loader reparenting more elegantly? this seems deeply unlikely.
+	if ref.Parent == self._root then
+		maid._current = self:_addToLoaderCount(1)
+	end
+
+	maid:GiveTask(ref:GetPropertyChangedSignal("Parent"):Connect(function()
+		if ref.Parent == self._root then
+			maid._current = self:_addToLoaderCount(1)
+		else
+			maid._current = nil
+		end
+	end))
+
+	return maid
+end
+
+--[=[
+	Cleans up the replicator disconnecting all events and cleaning up
+	created instances.
+]=]
+function LoaderAdder:Destroy()
+	self._maid:DoCleaning()
+	setmetatable(self, nil)
+end
+
+return LoaderAdder