feat: search by extension titles

Author: rniraclefire

src/Extension.luau

@@ -12,42 +12,51 @@ Extension.__index = Extension
 
 Extension.allExtensions = Charm.atom({} :: { [Extension]: true })
 
-Extension.allCommands = Charm.computed(function(): { Command.Command }
+Extension.sortedByTitle = Charm.computed(function(): { Extension }
 	local result = {}
 	for extension in Extension.allExtensions() do
-		table.move(extension._commands, 1, #extension._commands, #result + 1, result)
+		table.insert(result, extension)
 	end
-	table.sort(result, Command.sortByTitle)
+	table.sort(result, function(lhs: Extension, rhs: Extension): boolean
+		return lhs._metadata.title < rhs._metadata.title
+	end)
 	return result
 end)
 
 Extension.extensionTitles = Charm.computed(function(): { string }
-	local allExtensions = Extension.allExtensions()
+	local allExtensions = Extension.sortedByTitle()
 	local result = table.create(#allExtensions) :: { string }
-	for ext in allExtensions do
+	for _, ext in allExtensions do
 		table.insert(result, ext._metadata.title)
 	end
 	table.sort(result)
 	return result
 end)
 
-Extension.commandTitles = Charm.computed(function(): { string }
+Extension.allCommands = Charm.computed(function(): { Command.Command }
+	local result = {}
+	for extension in Extension.allExtensions() do
+		table.move(extension._commands, 1, #extension._commands, #result + 1, result)
+	end
+	table.sort(result, Command.sortByTitle)
+	return result
+end)
+
+Extension.commandToIndex = Charm.computed(function(): { [Command.Command]: number }
 	local allCommands = Extension.allCommands()
-	local result = table.create(#allCommands) :: { string }
-	for i, cmd in allCommands do
-		result[i] = cmd._metadata.title
+	local result = table.create(#allCommands) :: { [Command.Command]: number }
+	for index, command in allCommands do
+		result[command] = index
 	end
 	return result
 end)
 
-Extension.sortedByTitle = Charm.computed(function(): { Extension }
-	local result = {}
-	for extension in Extension.allExtensions() do
-		table.insert(result, extension)
+Extension.commandTitles = Charm.computed(function(): { string }
+	local allCommands = Extension.allCommands()
+	local result = table.create(#allCommands) :: { string }
+	for i, cmd in allCommands do
+		result[i] = cmd._metadata.title
 	end
-	table.sort(result, function(lhs: Extension, rhs: Extension): boolean
-		return lhs._metadata.title < rhs._metadata.title
-	end)
 	return result
 end)
 

src/launcher/LauncherStore.luau

@@ -18,17 +18,46 @@ LauncherStore.commandContext = nil :: CommandContext.CommandContext?
 LauncherStore.searchResults = Charm.computed(function(): { Command.Command }
 	local search = LauncherStore.search()
 	local allCommands = Extension.allCommands()
+	local commandToIndex = Extension.commandToIndex()
+
 	local haystack = table.clone(allCommands)
 	if search ~= "" then
-		local results = fzy.filter(search, Extension.commandTitles(), false)
-		table.sort(results, function(lhs: { number }, rhs: { number })
-			return lhs[3] < rhs[3]
+		local commandResults = fzy.filter(search, Extension.commandTitles(), false)
+
+		local extensions = Extension.sortedByTitle()
+		local extensionResults = fzy.filter(search, Extension.extensionTitles(), false)
+
+		local combined: { [number]: { number } } = {}
+		for _, result in commandResults do
+			-- command titles has priority over extension titles
+			result[3] *= 1000
+			combined[result[1]] = result
+		end
+
+		for _, result in extensionResults do
+			for _, command in extensions[result[1]]._commands do
+				local commandIndex = commandToIndex[command]
+				local commandResult = combined[commandIndex]
+				if commandResult then
+					commandResult[3] += result[3]
+				else
+					combined[commandIndex] = { commandToIndex[command], 0, result[3] }
+				end
+			end
+		end
+
+		table.sort(combined, function(lhs: { number }, rhs: { number })
+			-- There are going to be gaps because some commands will be
+			-- filtered.
+			return if lhs and rhs then lhs[3] < rhs[3] else not not rhs
 		end)
-		haystack = table.create(#results) :: { Command.Command }
-		for _, result in results do
+
+		haystack = table.create(#combined) :: { Command.Command }
+		for _, result in combined do
 			table.insert(haystack, allCommands[result[1]])
 		end
 	end
+
 	return haystack
 end)