@quenty/inputkeymaputils 4.2.1-canary.256.edbbcfc.0 → 5.0.0

package/CHANGELOG.md

@@ -3,7 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [4.2.1-canary.256.edbbcfc.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@4.2.0...@quenty/inputkeymaputils@4.2.1-canary.256.edbbcfc.0) (2022-03-27)
+# [5.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@4.3.0...@quenty/inputkeymaputils@5.0.0) (2022-05-21)
+
+**Note:** Version bump only for package @quenty/inputkeymaputils
+
+
+
+
+
+# [4.3.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@4.2.0...@quenty/inputkeymaputils@4.3.0) (2022-03-27)
 
 **Note:** Version bump only for package @quenty/inputkeymaputils
 

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2014-2021 Quenty
+Copyright (c) 2014-2022 Quenty
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -13,9 +13,13 @@
 
 Utility methods for input map
 
-<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/InputKeyMapUtils">View docs →</a></div>
+<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/InputKeyMapList">View docs →</a></div>
 
 ## Installation
 ```
 npm install @quenty/inputkeymaputils --save
-```
+```
+
+## Design
+
+Note this system is designed to simple hold data, it doesn't do any binding with that data. So basically, an InputKeyMap can hold the information on what to bind, and what preferences are in a structured way.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/inputkeymaputils",
-  "version": "4.2.1-canary.256.edbbcfc.0",
+  "version": "5.0.0",
   "description": "Utility methods for input map",
   "keywords": [
     "Roblox",
@@ -26,12 +26,21 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/inputmode": "4.1.1-canary.256.edbbcfc.0",
-    "@quenty/loader": "4.0.1-canary.256.edbbcfc.0",
-    "@quenty/table": "2.1.2-canary.256.edbbcfc.0"
+    "@quenty/baseobject": "^5.0.0",
+    "@quenty/brio": "^6.0.0",
+    "@quenty/inputmode": "^5.0.0",
+    "@quenty/loader": "^5.0.0",
+    "@quenty/maid": "^2.3.0",
+    "@quenty/observablecollection": "^3.0.0",
+    "@quenty/rx": "^5.0.0",
+    "@quenty/servicebag": "^5.0.0",
+    "@quenty/statestack": "^6.0.0",
+    "@quenty/table": "^3.0.0",
+    "@quenty/valuebaseutils": "^5.0.0",
+    "@quenty/valueobject": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "edbbcfc38516772a791d50dc43cd6b304ffc4aff"
+  "gitHead": "9f7eaea7543c33c89d2e32c38491b13f9271f4f7"
 }

package/src/Client/InputKeyMap.lua

@@ -0,0 +1,55 @@
+--[=[
+	This represents a list of key bindings for a specific mode. While this is a useful object to query
+	for showing icons and input hints to the user, in general, it is recommended that binding occur
+	at the list level instead of at the input mode level. That way, if the user switches to another input
+	mode then input is immediately processed.
+
+	@class InputKeyMap
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local ValueObject = require("ValueObject")
+local InputMode = require("InputMode")
+
+local InputKeyMap = setmetatable({}, BaseObject)
+InputKeyMap.ClassName = "InputKeyMap"
+InputKeyMap.__index = InputKeyMap
+
+function InputKeyMap.new(inputMode, inputTypes)
+	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+	assert(type(inputTypes) == "table" or inputTypes == nil, "Bad inputTypes")
+
+	local self = setmetatable(BaseObject.new(), InputKeyMap)
+
+	self._inputMode = assert(inputMode, "No inputMode")
+
+	self._inputType = ValueObject.new(inputTypes or {})
+	self._maid:GiveTask(self._inputType)
+
+	return self
+end
+
+--[=[
+	Gets the input mode for this keymap. This will not change.
+]=]
+function InputKeyMap:GetInputMode()
+	return self._inputMode
+end
+
+function InputKeyMap:SetInputTypesList(inputTypes)
+	assert(type(inputTypes) == "table", "Bad inputTypes")
+
+	self._inputType.Value = inputTypes
+end
+
+function InputKeyMap:ObserveInputTypesList()
+	return self._inputType:Observe()
+end
+
+function InputKeyMap:GetInputTypesList()
+	return self._inputType.Value
+end
+
+return InputKeyMap

package/src/Client/InputKeyMapList.lua

@@ -0,0 +1,364 @@
+--[=[
+	An input key map list provides a mapping of input modes to input keys.
+	One of these should generally exist per an action with unique bindings.
+
+	All inputs should be bound while this action is active. We can further
+	query inputs per an input mode to display only relevant key bindings to
+	the user.
+
+	```lua
+	local inputKeyMapList = InputKeyMapList.new("BOOST", {
+		InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.LeftControl });
+		InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonX });
+		InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary1") });
+	})
+
+	maid:GiveTask(Rx.combineLatest({
+		isRobloxTouchButton = inputKeyMapList:ObserveIsRobloxTouchButton();
+		inputEnumsList = inputKeyMapList:ObserveInputEnumsList();
+	}):Subscribe(function(state)
+		maid._contextMaid = nil
+
+		local contextMaid = Maid.new()
+
+		ContextActionService:BindActionAtPriority(
+			"MyAction",
+			function(_actionName, userInputState, inputObject)
+				print("Process input", inputObject)
+			end,
+			state.isRobloxTouchButton,
+			Enum.ContextActionPriority.High.Value,
+			unpack(state.inputEnumsList))
+
+			maid._contextMaid = contextMaid
+		end))
+	end))
+	```
+
+	@class InputKeyMapList
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InputKeyMap = require("InputKeyMap")
+local ObservableMap = require("ObservableMap")
+local BaseObject = require("BaseObject")
+local InputModeSelector = require("InputModeSelector")
+local Observable = require("Observable")
+local Maid = require("Maid")
+local Rx = require("Rx")
+local ObservableCountingMap = require("ObservableCountingMap")
+local InputMode = require("InputMode")
+local SlottedTouchButtonUtils = require("SlottedTouchButtonUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local Brio = require("Brio")
+local StateStack = require("StateStack")
+local InputTypeUtils = require("InputTypeUtils")
+
+local InputKeyMapList = setmetatable({}, BaseObject)
+InputKeyMapList.ClassName = "InputKeyMapList"
+InputKeyMapList.__index = InputKeyMapList
+
+--[=[
+	Constructs a new InputKeyMapList
+
+	@param inputMapName string
+	@param inputKeyMapList { InputKeyMap }
+	@return InputKeyMapList
+]=]
+function InputKeyMapList.new(inputMapName, inputKeyMapList)
+	local self = setmetatable(BaseObject.new(), InputKeyMapList)
+
+	self._inputKeyMapListName = assert(inputMapName, "No inputMapName")
+
+	self._inputModeToInputKeyMap = ObservableMap.new()
+	self._maid:GiveTask(self._inputModeToInputKeyMap)
+
+	for _, inputKeyMap in pairs(inputKeyMapList) do
+		self:Add(inputKeyMap)
+	end
+
+	return self
+end
+
+--[=[
+	Returns whether this value is an InputKeyMapList
+
+	@param value any
+	@return boolean
+]=]
+function InputKeyMapList.isInputKeyMapList(value)
+	return type(value) == "table" and getmetatable(value) == InputKeyMapList
+end
+
+--[=[
+	Adds an input key map into the actual list
+	@param inputKeyMap InputKeyMap
+]=]
+function InputKeyMapList:Add(inputKeyMap)
+	assert(inputKeyMap, "Bad inputKeyMap")
+
+	self._maid[inputKeyMap:GetInputMode()] = inputKeyMap
+	self._inputModeToInputKeyMap:Set(inputKeyMap:GetInputMode(), inputKeyMap)
+end
+
+--[=[
+	Gets the list name and returns it. Used by an input key map provider
+	@return string
+]=]
+function InputKeyMapList:GetListName()
+	return self._inputKeyMapListName
+end
+
+function InputKeyMapList:SetInputTypesList(inputMode, inputTypes)
+	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+	assert(type(inputTypes) == "table" or inputTypes == nil, "Bad inputTypes")
+
+	if inputTypes == nil then
+		self._inputModeToInputKeyMap:Remove(inputMode)
+		self._maid[inputMode] = nil
+	else
+		local inputKeyMap = self._inputModeToInputKeyMap:Get(inputMode)
+		if not inputKeyMap then
+			self:Add(InputKeyMap.new(inputMode, inputTypes))
+		else
+			inputKeyMap:SetInputTypesList(inputTypes)
+		end
+	end
+end
+
+--[=[
+	Removes the entry for the inputmode
+
+	@param inputMode InputMode
+]=]
+function InputKeyMapList:RemoveInputMode(inputMode)
+	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+
+	self:SetInputTypesList(inputMode, nil)
+end
+
+--[=[
+	Observes the input enums list
+
+	@return InputModeSelector
+]=]
+function InputKeyMapList:GetNewInputModeSelector()
+	return InputModeSelector.fromObservableBrio(self:ObserveInputModesBrio())
+end
+
+--[=[
+	@return Observable<Brio<InputKeyMap>>
+]=]
+function InputKeyMapList:ObserveInputKeyMapsBrio()
+	return self._inputModeToInputKeyMap:ObserveValuesBrio()
+end
+
+--[=[
+	@return Observable<Brio<InputMode>>
+]=]
+function InputKeyMapList:ObserveInputModesBrio()
+	return self._inputModeToInputKeyMap:ObserveKeysBrio()
+end
+
+--[=[
+	Observes the input types for the active input map
+
+	@return Observable<InputKeyMap>
+]=]
+function InputKeyMapList:ObserveActiveInputKeyMap()
+	return self:ObserveActiveInputMode():Pipe({
+		Rx.switchMap(function(activeInputMode)
+			if activeInputMode then
+				return self._inputModeToInputKeyMap:ObserveValueForKey(activeInputMode)
+			else
+				return Rx.of(nil)
+			end
+		end);
+	})
+end
+
+--[=[
+	Observes the input types for the active input map.
+
+	:::warning
+	This should be used for hinting inputs, but it's preferred to
+	bind inputs for all modes. See [InputKeyMapList.ObserveInputEnumsList]
+	:::
+
+	@return Observable<{ InputType }?>
+]=]
+function InputKeyMapList:ObserveActiveInputTypesList()
+	return self:ObserveActiveInputKeyMap():Pipe({
+		Rx.switchMap(function(activeInputMap)
+			if activeInputMap then
+				return activeInputMap:ObserveInputTypesList()
+			else
+				return Rx.of(nil)
+			end
+		end);
+		Rx.distinct();
+	})
+end
+
+--[=[
+	Observes the active input mode currently selected.
+
+	@return Observable<InputMode?>
+]=]
+function InputKeyMapList:ObserveActiveInputMode()
+	return Observable.new(function(sub)
+		local maid = Maid.new()
+
+		local selector = self:GetNewInputModeSelector()
+		maid:GiveTask(selector)
+
+		maid:GiveTask(selector.Changed:Connect(function()
+			sub:Fire(selector.Value)
+		end))
+		sub:Fire(selector.Value)
+
+		return maid
+	end)
+end
+
+--[=[
+	Observes whether the input list includes tapping in the world somewhere.
+
+	@return Observable<boolean>
+]=]
+function InputKeyMapList:ObserveIsTapInWorld()
+	self:_ensureInit()
+
+	return self._isTapInWorld:Observe()
+end
+
+--[=[
+	Observes whether the input list includes a Roblox button.
+
+	@return Observable<boolean>
+]=]
+function InputKeyMapList:ObserveIsRobloxTouchButton()
+	self:_ensureInit()
+
+	return self._isRobloxTouchButton:Observe()
+end
+
+--[=[
+	Gets whether the input list includes a Roblox button.
+
+	@return boolean
+]=]
+function InputKeyMapList:IsRobloxTouchButton()
+	self:_ensureInit()
+
+	return self._isRobloxTouchButton:GetState()
+end
+
+--[=[
+	Gets whether the input list includes a Roblox button.
+
+	@return boolean
+]=]
+function InputKeyMapList:IsTouchTapInWorld()
+	self:_ensureInit()
+
+	return self._isTapInWorld:GetState()
+end
+
+--[=[
+	Observes the input enums list, which can be used for bindings.
+
+	@return Observable<{UserInputType | KeyCode}>
+]=]
+function InputKeyMapList:ObserveInputEnumsList()
+	self:_ensureInit()
+
+	return self._inputTypesForBinding:ObserveKeysList()
+end
+
+--[=[
+	Observes the input enums set
+
+	@return Observable<{[UserInputType | KeyCode]: true }>
+]=]
+function InputKeyMapList:ObserveInputEnumsSet()
+	self:_ensureInit()
+
+	return self._inputTypesForBinding:ObserveKeysSet()
+end
+
+--[=[
+	Observes slotted touch button data in the input modes.
+
+	@return Observable<SlottedTouchButton>
+]=]
+function InputKeyMapList:ObserveSlottedTouchButtonDataBrio()
+	return self._inputModeToInputKeyMap:ObservePairsBrio():Pipe({
+		RxBrioUtils.flatMapBrio(function(inputMode, inputKeyMap)
+			return inputKeyMap:ObserveInputTypesList():Pipe({
+				Rx.switchMap(function(inputTypesList)
+					local valid = {}
+					for _, inputType in pairs(inputTypesList) do
+						if SlottedTouchButtonUtils.isSlottedTouchButton(inputType) then
+							local data = SlottedTouchButtonUtils.createTouchButtonData(inputType.slotId, inputMode)
+							table.insert(valid, Brio.new(data))
+						end
+					end
+
+					if not next(valid) then
+						return Rx.EMPTY
+					else
+						return Rx.of(unpack(valid))
+					end
+				end)
+			})
+		end);
+	})
+end
+
+function InputKeyMapList:_ensureInit()
+	if self._inputTypesForBinding then
+		return self._inputTypesForBinding
+	end
+
+	self._inputTypesForBinding = ObservableCountingMap.new()
+	self._maid:GiveTask(self._inputTypesForBinding)
+
+	self._isTapInWorld = StateStack.new(false)
+	self._maid:GiveTask(self._isTapInWorld)
+
+	self._isRobloxTouchButton = StateStack.new(false)
+	self._maid:GiveTask(self._isRobloxTouchButton)
+
+	-- Listen
+	self._maid:GiveTask(self._inputModeToInputKeyMap:ObserveValuesBrio():Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local inputKeyMapMaid = brio:ToMaid()
+		local inputKeyMap = brio:GetValue()
+
+		inputKeyMapMaid:GiveTask(inputKeyMap:ObserveInputTypesList():Subscribe(function(inputTypes)
+			local maid = Maid.new()
+
+			for _, inputType in pairs(inputTypes) do
+				-- only emit enum items
+				if typeof(inputType) == "EnumItem" then
+					maid:GiveTask(self._inputTypesForBinding:Add(inputType))
+				elseif InputTypeUtils.isTapInWorld(inputType) then
+					maid:GiveTask(self._isTapInWorld:PushState(true))
+				elseif InputTypeUtils.isRobloxTouchButton(inputType) then
+					maid:GiveTask(self._isRobloxTouchButton:PushState(true))
+				end
+			end
+
+			inputKeyMapMaid._current = maid
+		end))
+	end))
+
+	return self._inputTypesForBinding
+end
+
+return InputKeyMapList

package/src/Client/InputKeyMapListProvider.lua

@@ -0,0 +1,147 @@
+--[=[
+	Centralizes input of keys. You can construct a new provider in a
+	package and key bindings can be recovered from it. This is designed
+	for user configuration/rebindings.
+
+	```lua
+	local inputMapProvider = InputKeyMapListProvider.new("General", function(self)
+		self:Add(InputKeyMapList.new("JUMP", {
+			InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.Space });
+			InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonA });
+			InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary3") });
+		}))
+		self:Add(InputKeyMapList.new("HONK", {
+			InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.H });
+			InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.DPadUp });
+			InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary2") });
+		}))
+		self:Add(InputKeyMapList.new("BOOST", {
+			InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.LeftControl });
+			InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonX });
+			InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary4") });
+		}))
+	end)
+
+	local inputMap = serviceBag:GetService(inputMapProvider)
+
+	serviceBag:Init()
+	serviceBag:Start()
+	```
+
+	@class InputKeyMapListProvider
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local Maid = require("Maid")
+local InputKeyMapServiceClient = require("InputKeyMapServiceClient")
+
+local InputKeyMapListProvider = {}
+InputKeyMapListProvider.ClassName = "InputKeyMapListProvider"
+InputKeyMapListProvider.__index = InputKeyMapListProvider
+
+--[=[
+	Constructs a new InputKeyMapListProvider. The name will be used for retrieval,
+	for example, if the dialog system needs to get a general input hint to show
+	to the user.
+
+	@param providerName string -- Name to use for global specification.
+	@param createDefaults callback -- Callback to construct the default items on init
+	@return InputKeyMapList
+]=]
+function InputKeyMapListProvider.new(providerName, createDefaults)
+	local self = setmetatable({}, InputKeyMapListProvider)
+
+	self._providerName = assert(providerName, "No providerName")
+	self._createDefaults = assert(createDefaults, "No createDefaults")
+
+	return self
+end
+
+--[=[
+	Gets this providers name
+	@return string
+]=]
+function InputKeyMapListProvider:GetProviderName()
+	return self._providerName
+end
+
+--[=[
+	Gets an input key map list for the given name. Errors if it is not
+	defined.
+
+	@param keyMapListName string
+	@return InputKeyMapList
+]=]
+function InputKeyMapListProvider:GetInputKeyMapList(keyMapListName)
+	local keyMapList = self:FindInputKeyMapList(keyMapListName)
+	if not keyMapList then
+		error(("Bad keyMapListName %q"):format(tostring(keyMapListName)))
+	end
+
+	return keyMapList
+end
+
+--[=[
+	Finds an input key map list for the given name
+	@param keyMapListName string
+	@return InputKeyMapList
+]=]
+function InputKeyMapListProvider:FindInputKeyMapList(keyMapListName)
+	assert(type(keyMapListName) == "string", "Bad keyMapListName")
+
+	if not self._inputKeyMapLists then
+		if not RunService:IsRunning() then
+			-- Test mode initialize
+			self._maid = Maid.new()
+			self:_ensureDefaultsInit()
+		else
+			error("Not initialized, make sure to retrieve via serviceBag and init")
+		end
+	end
+
+	return self._inputKeyMapLists[keyMapListName]
+end
+
+function InputKeyMapListProvider:Add(inputKeyMapList)
+	assert(inputKeyMapList, "Bad inputKeyMapList")
+	assert(self._maid, "Not initialized")
+
+	if self._inputKeyMapLists[inputKeyMapList:GetListName()] then
+		error(("Already added %q"):format(inputKeyMapList:GetListName()))
+	end
+
+	self._inputKeyMapLists[inputKeyMapList:GetListName()] = inputKeyMapList
+	self._maid:GiveTask(inputKeyMapList)
+end
+
+function InputKeyMapListProvider:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._serviceBag:GetService(InputKeyMapServiceClient):RegisterProvider(self)
+	self._maid = Maid.new()
+
+	self:_ensureDefaultsInit()
+end
+
+function InputKeyMapListProvider:_ensureDefaultsInit()
+	if not self._inputKeyMapLists then
+		self._inputKeyMapLists = {}
+
+		self._createDefaults(self, self._serviceBag)
+	end
+end
+
+function InputKeyMapListProvider:Start()
+	-- empty function
+end
+
+function InputKeyMapListProvider:Destroy()
+	self._maid:DoCleaning()
+	self._inputKeyMapLists = nil
+end
+
+return InputKeyMapListProvider

package/src/Client/InputKeyMapServiceClient.lua

@@ -0,0 +1,66 @@
+--[=[
+	Not required to be initialized
+	@class InputKeyMapServiceClient
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local InputKeyMapServiceClient = {}
+
+function InputKeyMapServiceClient:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	self._providers = {}
+end
+
+function InputKeyMapServiceClient:RegisterProvider(provider)
+	assert(provider, "Bad provider")
+	assert(self._providers, "Not initialized")
+
+	local providerName = provider:GetProviderName()
+	if self._providers[providerName] then
+		error(("Already have a provider with name %q"):format(providerName))
+	end
+
+	self._providers[providerName] = provider
+end
+
+function InputKeyMapServiceClient:GetProvider(providerName)
+	assert(type(providerName) == "string", "Bad providerName")
+
+	return self._providers[providerName]
+end
+
+-- function InputKeyMapServiceClient:ObserveInputKeyMapList(providerName, inputKeyMapListName)
+-- 	assert(type(providerName) == "string", "Bad providerName")
+-- 	assert(type(inputKeyMapListName) == "string", "Bad inputKeyMapListName")
+
+-- end
+
+function InputKeyMapServiceClient:FindInputKeyMapList(providerName, inputKeyMapListName)
+	assert(type(providerName) == "string", "Bad providerName")
+	assert(type(inputKeyMapListName) == "string", "Bad inputKeyMapListName")
+
+	if not RunService:IsRunning() then
+		return nil
+	end
+
+	assert(self._providers, "Not initialized")
+	for _, provider in pairs(self._providers) do
+		if provider:GetProviderName() == providerName then
+			local found = provider:FindInputKeyMapList(inputKeyMapListName)
+			if found then
+				return found
+			end
+		end
+	end
+
+	return nil
+end
+
+
+
+return InputKeyMapServiceClient

package/src/Client/ProximityPromptInputUtils.lua

@@ -6,8 +6,9 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local InputKeyMapUtils = require("InputKeyMapUtils")
+local InputKeyMapList = require("InputKeyMapList")
 local INPUT_MODES = require("INPUT_MODES")
+local InputKeyMap = require("InputKeyMap")
 
 local ProximityPromptInputUtils = {}
 
@@ -17,13 +18,13 @@ local ProximityPromptInputUtils = {}
 	@param prompt ProximityPrompt
 	@return InputKeyMapList
 ]=]
-function ProximityPromptInputUtils.inputKeyMapFromPrompt(prompt)
+function ProximityPromptInputUtils.newInputKeyMapFromPrompt(prompt)
 	assert(typeof(prompt) == "Instance", "Bad prompt")
 
-	return {
-		InputKeyMapUtils.createKeyMap(INPUT_MODES.Gamepads, { prompt.GamepadKeyCode });
-		InputKeyMapUtils.createKeyMap(INPUT_MODES.Keyboard, { prompt.KeyboardKeyCode })
-	}
+	return InputKeyMapList.new("custom", {
+		InputKeyMap.new(INPUT_MODES.Gamepads, { prompt.GamepadKeyCode });
+		InputKeyMap.new(INPUT_MODES.Keyboard, { prompt.KeyboardKeyCode })
+	})
 end
 
 

package/src/Client/Types/InputTypeUtils.lua

@@ -0,0 +1,67 @@
+--[=[
+	@class InputTypeUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local SlottedTouchButtonUtils = require("SlottedTouchButtonUtils")
+
+local InputTypeUtils = {}
+
+--[=[
+	A valid input type that can be represented here.
+	@type InputType KeyCode | UserInputType | SlottedTouchButton | "TouchButton" | "Tap" | any
+	@within InputTypeUtils
+]=]
+
+--[=[
+	Returns true if the input type is specifying a tap in the world
+	@param inputKey any
+	@return boolean
+]=]
+function InputTypeUtils.isTapInWorld(inputKey)
+	return inputKey == "Tap"
+end
+
+--[=[
+	Returns true if the input type is specifying a Roblox touch button
+	@param inputKey any
+	@return boolean
+]=]
+function InputTypeUtils.isRobloxTouchButton(inputKey)
+	return inputKey == "TouchButton"
+end
+
+--[=[
+	Specifies a tap in the world
+	@return "Tap"
+]=]
+function InputTypeUtils.createTapInWorld()
+	return "Tap"
+end
+
+--[=[
+	Specifies a roblox touch button
+	@return "Tap"
+]=]
+function InputTypeUtils.createRobloxTouchButton()
+	return "TouchButton"
+end
+
+--[=[
+	Computes a unique id for an inputType which can be used
+	in a set to deduplicate/compare the objects. Used to know
+	when to exclude different types from each other.
+
+	@param inputType InputType
+	@return any
+]=]
+function InputTypeUtils.getUniqueKeyForInputType(inputType)
+	if SlottedTouchButtonUtils.isSlottedTouchButton(inputType) then
+		return inputType.slotId
+	else
+		return inputType
+	end
+end
+
+return InputTypeUtils

package/src/Client/Types/SlottedTouchButtonUtils.lua

@@ -0,0 +1,98 @@
+--[=[
+	@class SlottedTouchButtonUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local SlottedTouchButtonUtils = {}
+
+
+--[=[
+	Internal data representing a slotted touch button
+	@interface SlottedTouchButtonData
+	.slotId string
+	.inputMode InputMode
+	@within SlottedTouchButtonUtils
+]=]
+
+
+--[=[
+	A touch button that goes into a specific slot. This ensures
+	consistent slot positions.
+
+	@interface SlottedTouchButton
+	.type "SlottedTouchButton"
+	.slotId string
+	@within SlottedTouchButtonUtils
+]=]
+
+--[=[
+	Touch buttons should always show up in the same position
+	We use the SlotId to determine which slot we should put
+	these buttons in.
+
+	@param slotId string
+	@return SlottedTouchButton
+]=]
+function SlottedTouchButtonUtils.createSlottedTouchButton(slotId)
+	assert(slotId == "primary1"
+		or slotId == "primary2"
+		or slotId == "primary3"
+		or slotId == "primary4"
+		or slotId == "touchpad1", "Bad slotId")
+
+	return {
+		type = "SlottedTouchButton";
+		slotId = slotId;
+	}
+end
+
+--[=[
+	Returns whether an inputType is a SlottedTouchButton type
+
+	@param inputType any
+	@return boolean
+]=]
+function SlottedTouchButtonUtils.isSlottedTouchButton(inputType)
+	return type(inputType) == "table" and inputType.type == "SlottedTouchButton"
+end
+
+--[=[
+	Gets slotted touch button data for an inputKeyMapList
+
+	@param slotId string
+	@param inputMode InputMode
+	@return SlottedTouchButtonData
+]=]
+function SlottedTouchButtonUtils.createTouchButtonData(slotId, inputMode)
+	return {
+		slotId = slotId;
+		inputMode = inputMode;
+	}
+end
+
+--[=[
+	Gets slotted touch button data for an inputKeyMapList
+
+	@param inputKeyMapList InputKeyMapList
+	@return { SlottedTouchButtonData }
+]=]
+function SlottedTouchButtonUtils.getSlottedTouchButtonData(inputKeyMapList)
+	local slottedTouchButtons = {}
+
+	for _, inputKeyMap in pairs(inputKeyMapList) do
+		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
+		assert(inputKeyMap.inputTypes, "Bad inputKeyMap.inputTypes")
+
+		for _, touchButtonData in pairs(inputKeyMap.inputTypes) do
+			if SlottedTouchButtonUtils.isSlottedTouchButton(touchButtonData) then
+				table.insert(slottedTouchButtons, SlottedTouchButtonUtils.createTouchButtonData(
+					touchButtonData.slotId, inputKeyMap.inputMode))
+			end
+		end
+	end
+
+	return slottedTouchButtons
+end
+
+return SlottedTouchButtonUtils

package/test/default.project.json

@@ -0,0 +1,27 @@
+{
+  "name": "InputKeyMapUtilsTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "inputkeymaputils": {
+        "$className": "Folder",
+        "inputkeymaputils": {
+          "$path": ".."
+        },
+        "test": {
+          "$path": "modules"
+        }
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    },
+    "StarterPlayer": {
+      "StarterPlayerScripts": {
+        "Main": {
+          "$path": "scripts/Client"
+        }
+      }
+    }
+  }
+}

package/test/modules/Client/TestInputKeyMap.lua

@@ -0,0 +1,25 @@
+--[=[
+	Test input key map provider
+	@class TestInputKeyMap
+]=]
+local require = require(script.Parent.loader).load(script)
+
+local INPUT_MODES = require("INPUT_MODES")
+local InputKeyMap = require("InputKeyMap")
+local InputKeyMapList = require("InputKeyMapList")
+local InputKeyMapListProvider = require("InputKeyMapListProvider")
+local SlottedTouchButtonUtils = require("SlottedTouchButtonUtils")
+
+return InputKeyMapListProvider.new(script.Name, function(self)
+	self:Add(InputKeyMapList.new("JUMP", {
+		InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.Q });
+		InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonY });
+		InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary3") });
+	}))
+
+	self:Add(InputKeyMapList.new("HONK", {
+		InputKeyMap.new(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.H });
+		InputKeyMap.new(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonL1 });
+		InputKeyMap.new(INPUT_MODES.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary2") });
+	}))
+end)

package/test/scripts/Client/ClientMain.client.lua

@@ -0,0 +1,28 @@
+--[[
+	@class ClientMain
+]]
+local packages = game:GetService("ReplicatedStorage"):WaitForChild("Packages")
+
+local ContextActionService = game:GetService("ContextActionService")
+
+local INPUT_MODES = require(packages.INPUT_MODES)
+local serviceBag = require(packages.ServiceBag).new()
+
+serviceBag:GetService(packages.InputKeyMapServiceClient)
+local inputKeyMap = serviceBag:GetService(packages.TestInputKeyMap)
+
+-- Start game
+serviceBag:Init()
+serviceBag:Start()
+
+local keyMapList = inputKeyMap:GetInputKeyMapList("HONK")
+
+keyMapList:ObserveInputEnumsList():Subscribe(function(...)
+	print("activeInputTypes", ...)
+	ContextActionService:BindAction("actionTypes", function(_, _, inputObject)
+		print("Activated", inputObject.UserInputState)
+	end, false, ...)
+end)
+
+
+keyMapList:SetForInputMode(INPUT_MODES.Keypad, { Enum.KeyCode.Space })

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,7 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
+require(loader).bootstrapGame(ServerScriptService.inputkeymaputils)

package/src/Client/InputKeyMapUtils.lua

@@ -1,320 +0,0 @@
---[=[
-	Utility methods for input. Centralizes input. In the future, this will allow
-	user configuration.
-
-	```lua
-	local inputMap = {
-		JUMP = {
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.Space });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonA });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Touch, { InputKeyMapUtils.createSlottedTouchButton("primary3") });
-		};
-		HONK = {
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.H });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Gamepads, { Enum.KeyCode.DPadUp });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Touch, { InputKeyMapUtils.createSlottedTouchButton("primary2") });
-		};
-		BOOST = {
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.KeyboardAndMouse, { Enum.KeyCode.LeftControl });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Gamepads, { Enum.KeyCode.ButtonX });
-			InputKeyMapUtils.createKeyMap(INPUT_MODES.Touch, { InputKeyMapUtils.createSlottedTouchButton("primary4") });
-		};
-	}
-	```
-
-	Then, we can use these input maps in a variety of services, including [ScoredActionService] or
-	just binding directly to [ContextActionService].
-
-	```lua
-	local inputKeyMapList = inputMap.JUMP
-
-	ContextActionService:BindActionAtPriority(
-		"MyAction",
-		function(_actionName, userInputState, inputObject)
-			print("Process input", inputObject)
-		end,
-		InputKeyMapUtils.isRobloxTouchButton(inputKeyMapList),
-		Enum.ContextActionPriority.High.Value,
-		unpack(InputKeyMapUtils.getInputTypesForActionBinding(inputKeyMapList)))
-	```
-
-	@class InputKeyMapUtils
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local Set = require("Set")
-local Table = require("Table")
-
-local InputKeyMapUtils = {}
-
---[=[
-	A valid input type that can be represented here.
-	@type InputType KeyCode | UserInputType | SlottedTouchButton | "TouchButton" | "Tap" | any
-	@within InputKeyMapUtils
-]=]
-
---[=[
-	A grouping of input types for a specific input mode to use.
-
-	@interface InputKeyMap
-	.inputMode InputMode
-	.inputTypes { InputType }
-	@within InputKeyMapUtils
-]=]
-
---[=[
-	A mapping of input keys to maps
-	@type InputKeyMapList { InputKeyMap }
-	@within InputKeyMapUtils
-]=]
-
---[=[
-	Should be called "createInputKeyMap". Creates a new InputKeyMap.
-
-	@param inputMode InputMode
-	@param inputTypes { InputType }
-	@return InputKeyMap
-]=]
-function InputKeyMapUtils.createKeyMap(inputMode, inputTypes)
-	assert(type(inputMode) == "table", "Bad inputMode")
-	assert(type(inputTypes) == "table", "Bad inputTypes")
-
-	return Table.readonly({
-		inputMode = inputMode;
-		inputTypes = inputTypes;
-	})
-end
-
---[=[
-	@param inputKeyMapList InputKeyMapList
-	@return { KeyCode | UserInputType }
-]=]
-function InputKeyMapUtils.getInputTypesSetForActionBinding(inputKeyMapList)
-	return Set.fromList(InputKeyMapUtils.getInputTypesForActionBinding(inputKeyMapList))
-end
-
---[=[
-	Converts keymap into ContextActionService friendly types
-	@param inputKeyMapList InputKeyMapList
-	@return { KeyCode | UserInputType }
-]=]
-function InputKeyMapUtils.getInputTypesForActionBinding(inputKeyMapList)
-	assert(type(inputKeyMapList) == "table", "inputKeyMapList must be a table")
-	local types = {}
-
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
-		assert(inputKeyMap.inputTypes, "Bad inputKeyMap.inputTypes")
-
-		for _, _type in pairs(inputKeyMap.inputTypes) do
-			if typeof(_type) == "EnumItem" then
-				table.insert(types, _type)
-			end
-		end
-	end
-
-	return types
-end
-
---[=[
-	Given an inputMode, gets the relevant lists available
-	@param inputKeyMapList InputKeyMapList
-	@param inputMode InputMode
-	@return { InputKeyMap }
-]=]
-function InputKeyMapUtils.getInputTypeListForMode(inputKeyMapList, inputMode)
-	assert(type(inputKeyMapList) == "table", "inputKeyMapList must be a table")
-
-	local results = {}
-	local seen = {}
-
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		if inputKeyMap.inputMode == inputMode then
-			for _, inputType in pairs(inputKeyMap.inputTypes) do
-				if not seen then
-					seen[inputType] = true
-					table.insert(results, inputType)
-				end
-			end
-		end
-	end
-
-	return results
-end
-
---[=[
-	Gets a set of input types for a given mode from the list.
-
-	@param inputKeyMapList InputKeyMapList
-	@param inputMode InputMode
-	@return { [InputType] = true }
-]=]
-function InputKeyMapUtils.getInputTypeSetForMode(inputKeyMapList, inputMode)
-	assert(type(inputKeyMapList) == "table", "inputKeyMapList must be a table")
-
-	local results = {}
-
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		if inputKeyMap.inputMode == inputMode then
-			for _, inputType in pairs(inputKeyMap.inputTypes) do
-				results[inputType] = true
-			end
-		end
-	end
-
-	return results
-end
-
---[=[
-	Retrieves the set of input modes for a given list.
-
-	@param inputKeyMapList InputKeyMapList
-	@return { InputMode }
-]=]
-function InputKeyMapUtils.getInputModes(inputKeyMapList)
-	assert(type(inputKeyMapList) == "table", "inputKeyMapList must be a table")
-
-	local modes = {}
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		local mode = assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
-		table.insert(modes, mode)
-	end
-
-	return modes
-end
-
---[=[
-	Internal data representing a slotted touch button
-	@interface SlottedTouchButtonData
-	.slotId string
-	.inputMode InputMode
-	@within InputKeyMapUtils
-]=]
-
---[=[
-	Gets slotted touch button data for an inputKeyMapList
-
-	@param inputKeyMapList InputKeyMapList
-	@return { SlottedTouchButtonData }
-]=]
-function InputKeyMapUtils.getSlottedTouchButtonData(inputKeyMapList)
-	local slottedTouchButtons = {}
-
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
-		assert(inputKeyMap.inputTypes, "Bad inputKeyMap.inputTypes")
-
-		for _, touchButtonData in pairs(inputKeyMap.inputTypes) do
-			if InputKeyMapUtils.isSlottedTouchButton(touchButtonData) then
-				table.insert(slottedTouchButtons, {
-					slotId = touchButtonData.slotId;
-					inputMode = inputKeyMap.inputMode;
-				})
-			end
-		end
-	end
-
-	return slottedTouchButtons
-end
-
---[=[
-	Returns whether an inputType is a SlottedTouchButton type
-
-	@param inputType any
-	@return boolean
-]=]
-function InputKeyMapUtils.isSlottedTouchButton(inputType)
-	return type(inputType) == "table" and inputType.type == "SlottedTouchButton"
-end
-
---[=[
-	A touch button that goes into a specific slot. This ensures
-	consistent slot positions.
-
-	@interface SlottedTouchButton
-	.type "SlottedTouchButton"
-	.slotId string
-	@within InputKeyMapUtils
-]=]
-
---[=[
-	Touch buttons should always show up in the same position
-	We use the SlotId to determine which slot we should put
-	these buttons in.
-
-	@param slotId string
-	@return SlottedTouchButton
-]=]
-function InputKeyMapUtils.createSlottedTouchButton(slotId)
-	assert(slotId == "primary1"
-		or slotId == "primary2"
-		or slotId == "primary3"
-		or slotId == "primary4"
-		or slotId == "touchpad1", "Bad slotId")
-
-	return {
-		type = "SlottedTouchButton";
-		slotId = slotId;
-	}
-end
-
---[=[
-	Computes a unique id for an inputType which can be used
-	in a set to deduplicate/compare the objects. Used to know
-	when to exclude different types from each other.
-
-	@param inputType InputType
-	@return any
-]=]
-function InputKeyMapUtils.getUniqueKeyForInputType(inputType)
-	if InputKeyMapUtils.isSlottedTouchButton(inputType) then
-		return inputType.slotId
-	else
-		return inputType
-	end
-end
-
---[=[
-	Only returns true if we're a Roblox touch button
-	@param inputKeyMapList InputKeyMapList
-	@return boolean
-]=]
-function InputKeyMapUtils.isRobloxTouchButton(inputKeyMapList)
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
-		assert(inputKeyMap.inputTypes, "Bad inputKeyMap.inputTypes")
-
-		for _, _type in pairs(inputKeyMap.inputTypes) do
-			if _type == "TouchButton" then
-				return true
-			end
-		end
-	end
-
-	return false
-end
-
---[=[
-	Whether this input type is a tap in the world input (for touched events)
-	@param inputKeyMapList InputKeyMapList
-	@return boolean
-]=]
-function InputKeyMapUtils.isTapInWorld(inputKeyMapList)
-	assert(type(inputKeyMapList) == "table", "inputKeyMap must be a table")
-
-	for _, inputKeyMap in pairs(inputKeyMapList) do
-		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
-		assert(inputKeyMap.inputTypes, "Bad inputKeyMap.inputTypes")
-
-		for _, _type in pairs(inputKeyMap.inputTypes) do
-			if _type == "Tap" then
-				return true
-			end
-		end
-	end
-
-	return false
-end
-
-return InputKeyMapUtils