@quenty/loader 10.0.0 → 10.1.0

package/src/ScriptInfoUtils.lua

@@ -1,153 +0,0 @@
---[=[
-	@private
-	@class ScriptInfoUtils
-]=]
-
-local CollectionService = game:GetService("CollectionService")
-
-local loader = script.Parent
-local Utils = require(script.Parent.Utils)
-local BounceTemplateUtils = require(script.Parent.BounceTemplateUtils)
-
-local ScriptInfoUtils = {}
-
-ScriptInfoUtils.DEPENDENCY_FOLDER_NAME = "node_modules";
-ScriptInfoUtils.ModuleReplicationTypes = Utils.readonly({
-	CLIENT = "client";
-	SERVER = "server";
-	SHARED = "shared";
-	IGNORE = "ignore";
-	PLUGIN = "plugin";
-})
-
-function ScriptInfoUtils.createScriptInfo(instance, name, replicationMode)
-	assert(typeof(instance) == "Instance", "Bad instance")
-	assert(type(name) == "string", "Bad name")
-	assert(type(replicationMode) == "string", "Bad replicationMode")
-
-	return Utils.readonly({
-		name = name;
-		replicationMode = replicationMode;
-		instance = instance;
-	})
-end
-
-function ScriptInfoUtils.createScriptInfoLookup()
-	-- Server/client also contain shared entries
-	return Utils.readonly({
-		[ScriptInfoUtils.ModuleReplicationTypes.SERVER] = {}; -- [string name] = scriptInfo
-		[ScriptInfoUtils.ModuleReplicationTypes.CLIENT] = {};
-		[ScriptInfoUtils.ModuleReplicationTypes.SHARED] = {};
-		[ScriptInfoUtils.ModuleReplicationTypes.PLUGIN] = {};
-	})
-end
-
-function ScriptInfoUtils.getScriptInfoLookupForMode(scriptInfoLookup, replicationMode)
-	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
-	assert(type(replicationMode) == "string", "Bad replicationMode")
-
-	return scriptInfoLookup[replicationMode]
-end
-
-function ScriptInfoUtils.populateScriptInfoLookup(instance, scriptInfoLookup, lastReplicationMode)
-	assert(typeof(instance) == "Instance", "Bad instance")
-	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
-	assert(type(lastReplicationMode) == "string", "Bad lastReplicationMode")
-
-	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") or item:IsA("Camera") then
-						ScriptInfoUtils.populateScriptInfoLookup(item, scriptInfoLookup, replicationMode)
-					elseif item:IsA("ModuleScript") then
-						ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
-							ScriptInfoUtils.createScriptInfo(item, item.Name, replicationMode))
-					end
-				end
-			end
-		end
-	elseif instance:IsA("ModuleScript") then
-		if not BounceTemplateUtils.isBounceTemplate(instance) then
-			if instance == loader then
-				-- STRICT hack to support this module script as "loader" over "Nevermore" in replicated scenario
-				ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
-					ScriptInfoUtils.createScriptInfo(instance, "loader", lastReplicationMode))
-			else
-				ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
-					ScriptInfoUtils.createScriptInfo(instance, instance.Name, lastReplicationMode))
-			end
-		end
-	elseif instance:IsA("ObjectValue") then
-		error("ObjectValue links are not supported at this time for retrieving inline module scripts")
-	end
-end
-
-local AVAILABLE_IN_SHARED = {
-	["IKService"] = true;
-	["IKServiceClient"] = true;
-}
-
-function ScriptInfoUtils.isAvailableInShared(scriptInfo)
-	if CollectionService:HasTag(scriptInfo.instance, "LinkToShared") then
-		return true
-	end
-
-	-- Hack because we can't tag things in Rojo yet
-	return AVAILABLE_IN_SHARED[scriptInfo.name]
-end
-
-function ScriptInfoUtils.addToInfoMap(scriptInfoLookup, scriptInfo)
-	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
-	assert(type(scriptInfo) == "table", "Bad scriptInfo")
-
-	local replicationMode = assert(scriptInfo.replicationMode, "Bad replicationMode")
-	local replicationMap = assert(scriptInfoLookup[replicationMode], "Bad replicationMode")
-
-	ScriptInfoUtils.addToInfoMapForMode(replicationMap, scriptInfo)
-
-	if replicationMode == ScriptInfoUtils.ModuleReplicationTypes.SHARED then
-		ScriptInfoUtils.addToInfoMapForMode(
-			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.SERVER], scriptInfo)
-		ScriptInfoUtils.addToInfoMapForMode(
-			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.CLIENT], scriptInfo)
-	elseif ScriptInfoUtils.isAvailableInShared(scriptInfo) then
-		ScriptInfoUtils.addToInfoMapForMode(
-			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.SHARED], scriptInfo)
-	end
-end
-
-function ScriptInfoUtils.addToInfoMapForMode(replicationMap, scriptInfo)
-	if replicationMap[scriptInfo.name] then
-		warn(("Duplicate module %q in same package under same replication scope. Only using first one. \n- %q\n- %q")
-			:format(scriptInfo.name,
-				scriptInfo.instance:GetFullName(),
-				replicationMap[scriptInfo.name].instance:GetFullName()))
-		return
-	end
-
-	replicationMap[scriptInfo.name] = scriptInfo
-end
-
-function ScriptInfoUtils.getFolderReplicationMode(folderName, lastReplicationMode)
-	assert(type(folderName) == "string", "Bad folderName")
-	assert(type(lastReplicationMode) == "string", "Bad lastReplicationMode")
-
-	--Plugin always replicates further
-	if folderName == ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
-		return ScriptInfoUtils.ModuleReplicationTypes.IGNORE
-	elseif lastReplicationMode == ScriptInfoUtils.ModuleReplicationTypes.PLUGIN then
-		return lastReplicationMode
-	elseif folderName == "Shared" then
-		return ScriptInfoUtils.ModuleReplicationTypes.SHARED
-	elseif folderName == "Client" then
-		return ScriptInfoUtils.ModuleReplicationTypes.CLIENT
-	elseif folderName == "Server" then
-		return ScriptInfoUtils.ModuleReplicationTypes.SERVER
-	else
-		return lastReplicationMode
-	end
-end
-
-return ScriptInfoUtils

package/src/StaticLegacyLoader.lua

@@ -1,211 +0,0 @@
---[=[
-	@private
-	@class StaticLegacyLoader
-]=]
-
-local loader = script.Parent
-local ScriptInfoUtils = require(script.Parent.ScriptInfoUtils)
-local LoaderUtils = require(script.Parent.LoaderUtils)
-local BounceTemplateUtils = require(script.Parent.BounceTemplateUtils)
-
-local StaticLegacyLoader = {}
-StaticLegacyLoader.ClassName = "StaticLegacyLoader"
-StaticLegacyLoader.__index = StaticLegacyLoader
-
-function StaticLegacyLoader.new()
-	local self = setmetatable({
-		_packageLookups = {};
-	}, StaticLegacyLoader)
-
-	return self
-end
-
-function StaticLegacyLoader:__call(value)
-	return self:Require(value)
-end
-
-function StaticLegacyLoader:Lock()
-	error("Cannot start loader while not running")
-end
-
-function StaticLegacyLoader:Require(root, value)
-	if type(value) == "number" then
-		return require(value)
-	elseif type(value) == "string" then
-		-- use very slow module recovery mechanism
-		local module = self:_findModule(root, value)
-		if module then
-			self:_ensureFakeLoader(module)
-			return require(module)
-		else
-			error("Error: Library '" .. tostring(value) .. "' does not exist.", 2)
-		end
-	elseif typeof(value) == "Instance" and value:IsA("ModuleScript") then
-		return require(value)
-	else
-		error(("Error: module must be a string or ModuleScript, got '%s' for '%s'")
-			:format(typeof(value), tostring(value)))
-	end
-end
-
-function StaticLegacyLoader:_findModule(root, name)
-	assert(typeof(root) == "Instance", "Bad root")
-	assert(type(name) == "string", "Bad name")
-
-	-- Implement the node_modules recursive find algorithm
-	local packageRoot = self:_findPackageRoot(root)
-	while packageRoot do
-		-- Build lookup
-		local highLevelLookup = self:_getOrCreateLookup(packageRoot)
-		if highLevelLookup[name] then
-			return highLevelLookup[name]
-		end
-
-		-- Ok, search our package dependencies
-		local dependencies = packageRoot:FindFirstChild(ScriptInfoUtils.DEPENDENCY_FOLDER_NAME)
-		if dependencies then
-			for _, instance in pairs(dependencies:GetChildren()) do
-				if instance:IsA("Folder") and instance.Name:sub(1, 1) == "@" then
-					for _, child in pairs(instance:GetChildren()) do
-						local lookup = self:_getPackageFolderLookup(child)
-						if lookup[name] then
-							return lookup[name]
-						end
-					end
-				else
-					local lookup = self:_getPackageFolderLookup(instance)
-					if lookup[name] then
-						return lookup[name]
-					end
-				end
-			end
-		end
-
-		-- We failed to find anything... search up a level...
-		packageRoot = self:_findPackageRoot(packageRoot)
-	end
-
-	return nil
-end
-
-function StaticLegacyLoader:GetLoader(moduleScript)
-	assert(typeof(moduleScript) == "Instance", "Bad moduleScript")
-
-	return setmetatable({}, {
-		__call = function(_self, value)
-			return self:Require(moduleScript, value)
-		end;
-		__index = function(_self, key)
-			return self:Require(moduleScript, key)
-		end;
-	})
-end
-
-function StaticLegacyLoader:_getPackageFolderLookup(instance)
-	if instance:IsA("ObjectValue") then
-		if instance.Value then
-			return self:_getOrCreateLookup(instance.Value)
-		else
-			warn("[StaticLegacyLoader] - Bad link in packageFolder")
-			return {}
-		end
-	elseif instance:IsA("Folder") or instance:IsA("Camera") then
-		return self:_getOrCreateLookup(instance)
-	elseif instance:IsA("ModuleScript") then
-		return self:_getOrCreateLookup(instance)
-	else
-		warn(("Unknown instance %q (%s) in dependencyFolder - %q")
-			:format(instance.Name, instance.ClassName, instance:GetFullName()))
-		return {}
-	end
-end
-
-function StaticLegacyLoader:_getOrCreateLookup(packageFolderOrModuleScript)
-	assert(typeof(packageFolderOrModuleScript) == "Instance", "Bad packageFolderOrModuleScript")
-
-	if self._packageLookups[packageFolderOrModuleScript] then
-		return self._packageLookups[packageFolderOrModuleScript]
-	end
-
-	local lookup = {}
-
-	self:_buildLookup(lookup, packageFolderOrModuleScript)
-
-	self._packageLookups[packageFolderOrModuleScript] = lookup
-	return lookup
-end
-
-function StaticLegacyLoader:_buildLookup(lookup, instance)
-	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)
-			end
-		end
-	elseif instance:IsA("ModuleScript") then
-		lookup[instance.Name] = instance
-	end
-end
-
-function StaticLegacyLoader:_findPackageRoot(instance)
-	assert(typeof(instance) == "Instance", "Bad instance")
-
-	local current = instance.Parent
-
-	while current and current ~= game do
-		if LoaderUtils.isPackage(current) then
-			return current
-		elseif self:_couldBePackageRootTopLevel(current) then
-			return current
-		else
-			current = current.Parent
-		end
-	end
-
-	return nil
-end
-
-function StaticLegacyLoader:_couldBePackageRootTopLevel(current)
-	for _, instance in pairs(current:GetChildren()) do
-		if instance:IsA("Folder") and instance.Name:sub(1, 1) == "@" then
-			for _, item in pairs(instance:GetChildren()) do
-				if LoaderUtils.isPackage(item) then
-					return true
-				end
-			end
-		end
-	end
-
-	return true
-end
-
-function StaticLegacyLoader:_ensureFakeLoader(module)
-	assert(typeof(module) == "Instance", "Bad module")
-
-	local parent = module.Parent
-	if not parent then
-		warn("[StaticLegacyLoader] - No parent")
-		return
-	end
-
-	-- NexusUnitTest
-	-- luacheck: ignore
-	-- selene: allow(undefined_variable)
-	local shouldBeArchivable = Load and true or false
-
-	-- Already have link
-	local found = parent:FindFirstChild("loader")
-	if found then
-		if BounceTemplateUtils.isBounceTemplate(found) then
-			found.Archivable = shouldBeArchivable
-		end
-
-		return
-	end
-
-	local link = BounceTemplateUtils.create(loader, "loader")
-	link.Archivable = shouldBeArchivable
-	link.Parent = parent
-end
-
-return StaticLegacyLoader

package/src2/LoaderUtils.lua

@@ -1,3 +0,0 @@
--- Literally here just so old loading code works
-
-error("Not implemented")

package/src2/Utils.lua

@@ -1,106 +0,0 @@
---[=[
-	@private
-	@class Utils
-]=]
-
-local Utils = {}
-
-local function errorOnIndex(_, index)
-	error(string.format("Bad index %q", tostring(index)), 2)
-end
-
-local READ_ONLY_METATABLE = {
-	__index = errorOnIndex;
-	__newindex = errorOnIndex;
-}
-
-function Utils.readonly(_table)
-	return setmetatable(_table, READ_ONLY_METATABLE)
-end
-
-function Utils.count(_table)
-	local count = 0
-	for _, _ in pairs(_table) do
-		count = count + 1
-	end
-	return count
-end
-
-function Utils.getOrCreateValue(parent, instanceType, name, defaultValue)
-	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
-	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
-	assert(type(name) == "string", "Bad argument 'name'")
-
-	local foundChild = parent:FindFirstChild(name)
-	if foundChild then
-		if not foundChild:IsA(instanceType) then
-			warn(("[Utils.getOrCreateValue] - Value of type %q of name %q is of type %q in %s instead")
-				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
-		end
-
-		return foundChild
-	else
-		local newChild = Instance.new(instanceType)
-		newChild.Name = name
-		newChild.Value = defaultValue
-		newChild.Parent = parent
-
-		return newChild
-	end
-end
-
-function Utils.getValue(parent, instanceType, name, default)
-	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
-	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
-	assert(type(name) == "string", "Bad argument 'name'")
-
-	local foundChild = parent:FindFirstChild(name)
-	if foundChild then
-		if foundChild:IsA(instanceType) then
-			return foundChild.Value
-		else
-			warn(("[Utils.getValue] - Value of type %q of name %q is of type %q in %s instead")
-				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
-			return nil
-		end
-	else
-		return default
-	end
-end
-
-function Utils.setValue(parent, instanceType, name, value)
-	assert(typeof(parent) == "Instance", "Bad argument 'parent'")
-	assert(type(instanceType) == "string", "Bad argument 'instanceType'")
-	assert(type(name) == "string", "Bad argument 'name'")
-
-	local foundChild = parent:FindFirstChild(name)
-	if foundChild then
-		if not foundChild:IsA(instanceType) then
-			warn(("[Utils.setValue] - Value of type %q of name %q is of type %q in %s instead")
-				:format(instanceType, name, foundChild.ClassName, foundChild:GetFullName()))
-		end
-
-		foundChild.Value = value
-	else
-		local newChild = Instance.new(instanceType)
-		newChild.Name = name
-		newChild.Value = value
-		newChild.Parent = parent
-	end
-end
-
-
-function Utils.getOrCreateFolder(parent, folderName)
-	local found = parent:FindFirstChild(folderName)
-	if found then
-		return found
-	else
-		local folder = Instance.new("Folder")
-		folder.Name = folderName
-		folder.Parent = parent
-		return folder
-	end
-end
-
-
-return Utils

package/src2/init.lua

@@ -1,171 +0,0 @@
---[=[
-	Primary loader which handles bootstrapping different scenarios quickly
-
-	@class loader
-]=]
-
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local RunService = game:GetService("RunService")
-
-local DependencyUtils = require(script.Dependencies.DependencyUtils)
-local LoaderLinkCreator = require(script.LoaderLink.LoaderLinkCreator)
-local LoaderLinkUtils = require(script.LoaderLink.LoaderLinkUtils)
-local Maid = require(script.Maid)
-local PackageTrackerProvider = require(script.Dependencies.PackageTrackerProvider)
-local ReplicationType = require(script.Replication.ReplicationType)
-local ReplicationTypeUtils = require(script.Replication.ReplicationTypeUtils)
-local Replicator = require(script.Replication.Replicator)
-local ReplicatorReferences = require(script.Replication.ReplicatorReferences)
-
-local GLOBAL_PACKAGE_TRACKER = PackageTrackerProvider.new()
-
-local Loader = {}
-Loader.__index = Loader
-Loader.ClassName = "Loader"
-
-function Loader.new(packages, replicationType)
-	assert(typeof(packages) == "Instance", "Bad packages")
-	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
-
-	local self = setmetatable({}, Loader)
-
-	self._maid = Maid.new()
-
-	self._replicationType = assert(replicationType, "No replicationType")
-	self._packages = assert(packages, "No packages")
-
-	return self
-end
-
-function Loader.bootstrapGame(packages)
-	assert(typeof(packages) == "Instance", "Bad packages")
-
-	local self = Loader.new(packages, ReplicationTypeUtils.inferReplicationType())
-
-	if self._replicationType == ReplicationType.SERVER then
-		self:_setupLoaderPopulation()
-
-		-- Trade off security for performance
-		if RunService:IsStudio() then
-			packages.Parent = ReplicatedStorage
-		else
-			self:_setupClientReplication()
-		end
-	end
-
-	GLOBAL_PACKAGE_TRACKER:AddPackageRoot(packages)
-
-	return self
-end
-
-function Loader.bootstrapPlugin(packages)
-	assert(typeof(packages) == "Instance", "Bad packages")
-
-	local self = Loader.new(packages, ReplicationType.PLUGIN)
-
-	self:_setupLoaderPopulation()
-
-	GLOBAL_PACKAGE_TRACKER:AddPackageRoot(packages)
-
-	return self
-end
-
-function Loader.load(packagesOrModuleScript)
-	assert(typeof(packagesOrModuleScript) == "Instance", "Bad packagesOrModuleScript")
-
-	local self = Loader.new(packagesOrModuleScript, ReplicationTypeUtils.inferReplicationType())
-
-	return self
-end
-
-function Loader:__index(request)
-	if Loader[request] then
-		return Loader[request]
-	end
-
-	return self:_findDependency(request)
-end
-
-function Loader:__call(request)
-	if type(request) == "string" then
-		local module = self:_findDependency(request)
-		return require(module)
-	else
-		return require(request)
-	end
-end
-
-function Loader:_findDependency(request)
-	assert(type(request) == "string", "Bad request")
-
-	local packageTracker = GLOBAL_PACKAGE_TRACKER:FindPackageTracker(self._packages)
-	if packageTracker then
-		local foundDependency = packageTracker:ResolveDependency(request, self._replicationType)
-		if foundDependency then
-			return foundDependency
-		end
-
-		-- Otherwise let's fail with an error acknowledging that the module exists
-		if self._replicationType == ReplicationType.SERVER or self._replicationType == ReplicationType.SHARED then
-			local foundClientDependency = packageTracker:ResolveDependency(request, ReplicationType.CLIENT)
-			if foundClientDependency then
-				error(string.format("[Loader] - %q is only available on the client", foundClientDependency.Name))
-			end
-		end
-
-		if self._replicationType == ReplicationType.CLIENT or self._replicationType == ReplicationType.SHARED then
-			local foundServerDependency = packageTracker:ResolveDependency(request, ReplicationType.SERVER)
-			if foundServerDependency then
-				error(string.format("[Loader] - %q is only available on the server", foundServerDependency.Name))
-			end
-		end
-	end
-
-	-- Just standard dependency search
-	local foundBackup = DependencyUtils.findDependency(self._packages, request, self._replicationType)
-	if foundBackup then
-		if RunService:IsRunning() then
-			warn(string.format("[Loader] - Failed to find package %q in package tracker", request))
-		end
-
-		-- Ensure hoarcekat story has a link to use
-		-- TODO: Maybe add to global package cache instead...
-		local parent = foundBackup.Parent
-		if parent and not parent:FindFirstChild("loader") then
-			local link = LoaderLinkUtils.create(script, "loader")
-			link.Parent = parent
-		end
-
-		return foundBackup
-	end
-
-	-- TODO: Track location and provider install command
-	error(string.format("[Loader] - %q is not available. Please make this module or install it to the package requiring it.", request))
-	return nil
-end
-
-function Loader:_setupClientReplication()
-	local copy = self._maid:Add(Instance.new("Folder"))
-	copy.Name = self._packages.Name
-
-	local references = ReplicatorReferences.new()
-
-	local replicator = self._maid:Add(Replicator.new(references))
-	replicator:SetTarget(copy)
-	replicator:ReplicateFrom(self._packages)
-
-	self._maid:Add(LoaderLinkCreator.new(copy, references, true))
-
-	copy.Parent = ReplicatedStorage
-end
-
-function Loader:_setupLoaderPopulation()
-	self._maid:Add(LoaderLinkCreator.new(self._packages, nil, true))
-end
-
-function Loader:Destroy()
-	self._maid:DoCleaning()
-	setmetatable(self, nil)
-end
-
-return Loader