Plugins can now be a folder with a Main.luau file, Added @plugin alias for plugin folders, Added fs.removealias

Author: PhoenixWhitefire

apidump.json

@@ -430,6 +430,7 @@
         "promptsave": "function",
         "read": "function",
         "remove": "function",
+        "removealias": "function",
         "rename": "function",
         "resolvepath": "function",
         "resolvepathabsolute": "function",

lsp/api-docs.json

@@ -816,6 +816,9 @@
   "@phoenix/global/fs.remove": {
     "documentation": "* Removes everything at the given path\n* Throws an error upon failure"
   },
+  "@phoenix/global/fs.removealias": {
+    "documentation": "* Removes an alias previously defined with `fs.definealias`"
+  },
   "@phoenix/global/fs.rename": {
     "documentation": "* Renames the file at the given `Path` to have the `NewName`\n* Throws an error upon failure"
   },

lsp/api.d.luau

@@ -732,6 +732,7 @@ declare fs: {
   promptsave: (( DefaultLocation: string?, Filter: ( { string } | string)?, FilterName: string? ) -> (string?)),
   read: (( Path: string ) -> (string?, string?)),
   remove: (( Path: string ) -> ()),
+  removealias: (( Alias: string ) -> ()),
   rename: (( Path: string, NewName: string ) -> ()),
   resolvepath: (Path: string) -> string,
   resolvepathabsolute: (Path: string) -> string,

plugins/niko.luau

@@ -9,18 +9,18 @@ type ToolbarButton = Types.ToolbarButton
 local PluginManager = {}
 PluginManager.Plugins = {} :: { Plugin }
 local IsPluginManagementWindowOpen = false
-local PluginSettings: { [string]: { Enabled: boolean } } = {}
+local PluginSettings: { [string]: { Enabled: boolean }? } = {}
 
 local PLUGIN_SETTINGS_PATH = "./editor/plugin-settings.json"
 
-local function getPluginSettings(plugin: Plugin): index<typeof(PluginSettings), string>
+local function getPluginSettings(plugin: Plugin)
     local settings = PluginSettings[plugin.Path]
     if not settings then
         settings = { Enabled = true }
         PluginSettings[plugin.Path] = settings
     end
 
-    return settings
+    return assert(settings)
 end
 
 local function renderPluginManagement()
@@ -80,32 +80,56 @@ local function renderPluginManagement()
     end
 end
 
-local function loadPluginsRecursive(ParentPath)
+local function setPluginAlias(ParentPath: string?)
+    if ParentPath then
+        fs.definealias("plugin", ParentPath)
+    end
+end
+
+local function loadPlugin(Path, ParentPath: string?)
+    local co, err = task.loadfile(Path)
+
+    if co then
+        local success, data: Plugin = coroutine.resume(co)
+
+        if success then
+            data.Path = Path:sub(assert((Path:find("/plugins"))) + 1, #Path)
+            data.ParentPath = ParentPath
+            --table.freeze(data)
+
+            if typeof(data.Icon) == "string" then
+                setPluginAlias(ParentPath)
+                data.Icon = fs.resolvepath(data.Icon)
+                fs.removealias("plugin")
+            end
+
+            table.insert(PluginManager.Plugins, data)
+
+            if getPluginSettings(data).Enabled and data.OnLoad then
+                data:OnLoad()
+            end
+        else
+            warn(`PluginManager: Failed to load-execute plugin { Path }: { data }`)
+        end
+    else
+        warn(`PluginManager: Failed to load plugin { Path }: { err }`)
+    end
+end
+
+local function loadPlugins(ParentPath)
     for path, type in fs.listdir(ParentPath) do
         if type == "f" then
             if path:sub(#path - 4, #path) == ".luau" then
-                local co, err = task.loadfile(path)
-
-                if co then
-                    local success, data: Plugin = coroutine.resume(co)
-
-                    if success then
-                        data.Path = path:sub(assert((path:find("/plugins"))) + 1, #path)
-                        --table.freeze(data)
-                        table.insert(PluginManager.Plugins, data)
-
-                        if getPluginSettings(data).Enabled and data.OnLoad then
-                            data:OnLoad()
-                        end
-                    else
-                        print(`Failed to load-execute plugin {path}: {data}`)
-                    end
-                else
-                    print(`Failed to load plugin {path}: {err}`)
-                end
+                loadPlugin(path)
             end
         else
-            loadPluginsRecursive(path)
+            local mainScriptPath = path .. "/Main.luau"
+
+            if fs.isfile(mainScriptPath) then
+                loadPlugin(mainScriptPath, path)
+            else
+                warn(`PluginManager: Expected { mainScriptPath } to be valid`)
+            end
         end
     end
 end
@@ -116,16 +140,24 @@ function PluginManager.Load()
     end
 
     if fs.isfile(PLUGIN_SETTINGS_PATH) then
-        PluginSettings = json.parse(fs.read(PLUGIN_SETTINGS_PATH) or "") or {}
+        local settings = json.parse(fs.read(PLUGIN_SETTINGS_PATH) or "")
+
+        if typeof(settings) == "table" then
+            PluginSettings = settings :: { [string]: { Enabled: boolean }? }
+        else
+            warn(`PluginManager: Settings file corrupt: '{ settings }' ({ typeof(settings) })`)
+        end
     end
 
-    loadPluginsRecursive("./plugins")
+    loadPlugins("./plugins")
 end
 
 function PluginManager.Shutdown()
     for _, plugin in PluginManager.Plugins do
         if plugin.OnShutdown then
+            setPluginAlias(plugin.ParentPath)
             plugin:OnShutdown()
+            fs.removealias("plugin")
         end
     end
 
@@ -135,15 +167,19 @@ end
 function PluginManager.OnEditorStageChanged(OldStage: EditorStage, NewStage: EditorStage)
     for _, plugin in PluginManager.Plugins do
         if getPluginSettings(plugin).Enabled and plugin.OnEditorStageChanged and table.find(plugin.ActiveStages, NewStage) then
+            setPluginAlias(plugin.ParentPath)
             plugin:OnEditorStageChanged(OldStage, NewStage)
+            fs.removealias("plugin")
         end
     end
 end
 
 function PluginManager.OnUpdate(DeltaTime: number, CurrentStage: EditorStage)
     for _, plugin in PluginManager.Plugins do
         if getPluginSettings(plugin).Enabled and plugin.OnUpdate and table.find(plugin.ActiveStages, CurrentStage) then
+            setPluginAlias(plugin.ParentPath)
             plugin:OnUpdate(DeltaTime)
+            fs.removealias("plugin")
         end
     end
 
@@ -180,6 +216,12 @@ function PluginManager.GetToolbarButtons(CurrentStage: EditorStage): { ToolbarBu
     for _, plugin in PluginManager.Plugins do
         if getPluginSettings(plugin).Enabled and table.find(plugin.ActiveStages, CurrentStage) then
             for _, t in plugin.ToolbarButtons do
+                if t.Icon and t.Icon:find("@") then
+                    setPluginAlias(plugin.ParentPath)
+                    t.Icon = fs.resolvepath(t.Icon)
+                    fs.removealias("plugin")
+                end
+
                 table.insert(buttons, t)
             end
         end

resources/scripts/ed/PluginManager.luau

@@ -15,6 +15,7 @@ export type Plugin = {
     Description: string?,
     Icon: string?,
     Path: string,
+    ParentPath: string?,
     ActiveStages: { Stage },
     ToolbarButtons: { ToolbarButton },
 

resources/scripts/ed/Types.luau

@@ -30,9 +30,10 @@ namespace FileRW
 	// E.x.: with `::DefineAlias("modules", "scripts/modules")` the path
 	// "@modules/MyModule.luau" resolves to "scripts/modules/MyModule.luau"
 	void DefineAlias(const std::string& Alias, const std::string& Path);
+	void RemoveAlias(const std::string& Alias);
 	// When the path given begins with a `.` to indicate CWD, set the alias
 	void MakeCwdAliasOf(const std::string&);
 
-	std::string MakePathCwdRelative(std::string);
-	std::string MakePathAbsolute(std::string);
+	std::string ResolvePathNormalized(std::string);
+	std::string ResolvePathAbsolute(std::string);
 };

resources/textures/niko.png

@@ -36,7 +36,7 @@ std::string FileRW::ReadFile(const std::string& ShortPath, bool* Success)
 {
 	ZoneScoped;
 
-	const std::string actualPath = FileRW::MakePathCwdRelative(ShortPath);
+	const std::string actualPath = FileRW::ResolvePathNormalized(ShortPath);
 	ZoneText(ShortPath.data(), ShortPath.size());
 	ZoneText(actualPath.data(), actualPath.size());
 
@@ -86,7 +86,7 @@ bool FileRW::WriteFile(
 {
 	ZoneScoped;
 
-	std::string path = FileRW::MakePathCwdRelative(ShortPath);
+	std::string path = FileRW::ResolvePathNormalized(ShortPath);
 	ZoneText(ShortPath.data(), ShortPath.size());
 	ZoneText(path.data(), path.size());
 
@@ -120,7 +120,7 @@ bool FileRW::WriteFileCreateDirectories(
 {
 	ZoneScoped;
 
-	std::string path = FileRW::MakePathCwdRelative(ShortPath);
+	std::string path = FileRW::ResolvePathNormalized(ShortPath);
 	ZoneText(ShortPath.data(), ShortPath.size());
 	ZoneText(path.data(), path.size());
 
@@ -147,6 +147,12 @@ void FileRW::DefineAlias(const std::string& Alias, const std::string& Path)
 	s_AliasMap[Alias] = Path;
 }
 
+void FileRW::RemoveAlias(const std::string& Alias)
+{
+	if (const auto& it = s_AliasMap.find(Alias); it != s_AliasMap.end())
+		s_AliasMap.erase(it);
+}
+
 void FileRW::MakeCwdAliasOf(const std::string& Alias)
 {
 	s_CwdAliasing = Alias;
@@ -162,10 +168,7 @@ static std::string resolveAliasRecursive(std::string Path)
 	const auto& aliasIt = s_AliasMap.find(alias);
 
 	if (aliasIt == s_AliasMap.end())
-	{
-		Log.ErrorF("Invalid alias '{}' in path '{}'", alias, Path);
-		return Path;
-	}
+		RAISE_RTF("Invalid alias '{}' in path '{}'", alias, Path);
 	else
 		Path = aliasIt->second + Path.substr(aliasEnd, Path.size() - aliasEnd);
 
@@ -175,11 +178,11 @@ static std::string resolveAliasRecursive(std::string Path)
 	return Path;
 }
 
-std::string FileRW::MakePathCwdRelative(std::string Path)
+std::string FileRW::ResolvePathNormalized(std::string Path)
 {
 	if (Path.size() == 0)
 	{
-		Log.Warning("`MakePathCwdRelative` given a path 0 bytes in length!");
+		Log.Warning("`ResolvePathNormalized` given a path 0 bytes in length!");
 		return Path;
 	}
 
@@ -225,15 +228,15 @@ std::string FileRW::MakePathCwdRelative(std::string Path)
 	return Path;
 }
 
-std::string FileRW::MakePathAbsolute(std::string Path)
+std::string FileRW::ResolvePathAbsolute(std::string Path)
 {
 	if (Path.size() == 0)
 	{
-		Log.Warning("`MakePathAbsolute` given a path 0 bytes in length!");
+		Log.Warning("`ResolvePathAbsolute` given a path 0 bytes in length!");
 		return Path;
 	}
 
-	std::string cwd = MakePathCwdRelative(Path);
+	std::string cwd = ResolvePathNormalized(Path);
 	std::string abs = cwd;
 
 	if (abs[0] != '/' && abs[0] != '~' && (abs.size() < 2 || abs[1] != ':'))