@quenty/inputkeymaputils 5.3.1 → 6.0.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@5.3.1...@quenty/inputkeymaputils@6.0.0) (2022-08-14)
+
+**Note:** Version bump only for package @quenty/inputkeymaputils
+
+
+
+
+
 ## [5.3.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@5.3.0...@quenty/inputkeymaputils@5.3.1) (2022-08-11)
 
 **Note:** Version bump only for package @quenty/inputkeymaputils

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/inputkeymaputils",
-  "version": "5.3.1",
+  "version": "6.0.0",
   "description": "Utility methods for input map",
   "keywords": [
     "Roblox",
@@ -27,20 +27,23 @@
   ],
   "dependencies": {
     "@quenty/baseobject": "^5.1.0",
-    "@quenty/brio": "^6.2.0",
-    "@quenty/inputmode": "^5.2.0",
+    "@quenty/brio": "^7.0.0",
+    "@quenty/clienttranslator": "^7.0.0",
+    "@quenty/inputmode": "^6.0.0",
     "@quenty/loader": "^5.0.0",
     "@quenty/maid": "^2.4.0",
-    "@quenty/observablecollection": "^3.3.1",
-    "@quenty/rx": "^5.2.0",
+    "@quenty/observablecollection": "^4.0.0",
+    "@quenty/pseudolocalize": "^3.0.0",
+    "@quenty/rx": "^6.0.0",
     "@quenty/servicebag": "^5.1.0",
-    "@quenty/statestack": "^6.2.0",
+    "@quenty/statestack": "^7.0.0",
+    "@quenty/string": "^3.0.0",
     "@quenty/table": "^3.1.0",
-    "@quenty/valuebaseutils": "^5.2.1",
-    "@quenty/valueobject": "^5.2.0"
+    "@quenty/valuebaseutils": "^6.0.0",
+    "@quenty/valueobject": "^6.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "45ffe88b893e29690163a42c3830c983f6098a59"
+  "gitHead": "dbb62609f980983cc32da90acfef13e30ed41113"
 }

package/src/Client/InputKeyMapListUtils.lua

@@ -0,0 +1,108 @@
+--[=[
+	Client side utility helpers for observing input modes for the current client.
+
+	@class InputKeyMapListUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InputKeyMapList = require("InputKeyMapList")
+local InputModeTypeSelector = require("InputModeTypeSelector")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local Rx = require("Rx")
+local ServiceBag = require("ServiceBag")
+
+local InputKeyMapListUtils = {}
+
+--[=[
+	Observes the input enums list
+
+	@param inputKeyMapList InputKeyMapList
+	@param serviceBag ServiceBag
+	@return InputModeTypeSelector
+]=]
+function InputKeyMapListUtils.getNewInputModeTypeSelector(inputKeyMapList, serviceBag)
+	assert(InputKeyMapList.isInputKeyMapList(inputKeyMapList), "Bad inputKeyMapList")
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+
+	return InputModeTypeSelector.fromObservableBrio(serviceBag, inputKeyMapList:ObserveInputModesTypesBrio())
+end
+
+--[=[
+	Observes the input types for the active input map
+
+	@param inputKeyMapList InputKeyMapList
+	@param serviceBag ServiceBag
+	@return Observable<InputKeyMap>
+]=]
+function InputKeyMapListUtils.observeActiveInputKeyMap(inputKeyMapList, serviceBag)
+	assert(InputKeyMapList.isInputKeyMapList(inputKeyMapList), "Bad inputKeyMapList")
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+
+	return InputKeyMapListUtils.observeActiveInputModeType(inputKeyMapList, serviceBag):Pipe({
+		Rx.switchMap(function(activeInputModeType)
+			if activeInputModeType then
+				return inputKeyMapList:ObserveInputKeyMapForInputMode(activeInputModeType)
+			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]
+	:::
+
+	@param inputKeyMapList InputKeyMapList
+	@param serviceBag ServiceBag
+	@return Observable<{ InputType }?>
+]=]
+function InputKeyMapListUtils.observeActiveInputTypesList(inputKeyMapList, serviceBag)
+	assert(InputKeyMapList.isInputKeyMapList(inputKeyMapList), "Bad inputKeyMapList")
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+
+	return InputKeyMapListUtils.observeActiveInputKeyMap(inputKeyMapList, serviceBag):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.
+
+	@param inputKeyMapList InputKeyMapList
+	@param serviceBag ServiceBag
+	@return Observable<InputModeType?>
+]=]
+function InputKeyMapListUtils.observeActiveInputModeType(inputKeyMapList, serviceBag)
+	assert(InputKeyMapList.isInputKeyMapList(inputKeyMapList), "Bad inputKeyMapList")
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+
+	return Observable.new(function(sub)
+		local maid = Maid.new()
+
+		local selector = InputKeyMapListUtils.getNewInputModeTypeSelector(inputKeyMapList, serviceBag)
+		maid:GiveTask(selector)
+
+		maid:GiveTask(selector.Changed:Connect(function()
+			sub:Fire(selector.Value)
+		end))
+		sub:Fire(selector.Value)
+
+		return maid
+	end)
+end
+
+return InputKeyMapListUtils

package/src/Client/InputKeyMapServiceClient.lua

@@ -1,64 +1,62 @@
 --[=[
-	Not required to be initialized
 	@class InputKeyMapServiceClient
 ]=]
 
-local RunService = game:GetService("RunService")
+local require = require(script.Parent.loader).load(script)
+
+local Maid = require("Maid")
+local PseudoLocalize = require("PseudoLocalize")
 
 local InputKeyMapServiceClient = {}
+InputKeyMapServiceClient.ServiceName = "InputKeyMapServiceClient"
 
 function InputKeyMapServiceClient:Init(serviceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
 
-	self._providers = {}
-end
-
-function InputKeyMapServiceClient:RegisterProvider(provider)
-	assert(provider, "Bad provider")
-	assert(self._providers, "Not initialized")
+	-- External
+	self._serviceBag:GetService(require("InputModeServiceClient"))
 
-	local providerName = provider:GetProviderName()
-	if self._providers[providerName] then
-		error(("Already have a provider with name %q"):format(providerName))
-	end
-
-	self._providers[providerName] = provider
+	-- Internal
+	self._translator = self._serviceBag:GetService(require("InputKeyMapTranslator"))
+	self._registryService = self._serviceBag:GetService(require("InputKeyMapRegistryServiceShared"))
 end
 
-function InputKeyMapServiceClient:GetProvider(providerName)
-	assert(type(providerName) == "string", "Bad providerName")
-
-	return self._providers[providerName]
+function InputKeyMapServiceClient:FindInputKeyMapList(providerName, listName)
+	return self._registryService:FindInputKeyMapList(providerName, listName)
 end
 
--- function InputKeyMapServiceClient:ObserveInputKeyMapList(providerName, inputKeyMapListName)
--- 	assert(type(providerName) == "string", "Bad providerName")
--- 	assert(type(inputKeyMapListName) == "string", "Bad inputKeyMapListName")
+function InputKeyMapServiceClient:Start()
+	self:_ensureLocalizationEntries()
+end
 
--- end
+function InputKeyMapServiceClient:_ensureLocalizationEntries()
+	self._maid:GiveTask(self._registryService:ObserveInputKeyMapListsBrio():Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
 
-function InputKeyMapServiceClient:FindInputKeyMapList(providerName, inputKeyMapListName)
-	assert(type(providerName) == "string", "Bad providerName")
-	assert(type(inputKeyMapListName) == "string", "Bad inputKeyMapListName")
+		local inputKeyMapList = brio:GetValue()
 
-	if not RunService:IsRunning() then
-		return nil
-	end
+		local text = inputKeyMapList:GetBindingName()
 
-	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
+		local localizationTable = self._translator:GetLocalizationTable()
+		local key = inputKeyMapList:GetBindingTranslationKey()
+		local source = text
+		local context = ("InputKeyMapServiceClient.%s"):format(inputKeyMapList:GetListName())
+		local localeId = "en"
+		local value = text
 
-	return nil
+		localizationTable:SetEntryValue(key, source, context, localeId, value)
+		localizationTable:SetEntryValue(key, source, context,
+			PseudoLocalize.getDefaultPseudoLocaleId(),
+			PseudoLocalize.pseudoLocalize(value))
+	end))
 end
 
-
+function InputKeyMapServiceClient:Destroy()
+	self._maid:DoCleaning()
+end
 
 return InputKeyMapServiceClient

package/src/Client/InputKeyMapTranslator.lua

@@ -0,0 +1,7 @@
+--[[
+	@class InputKeyMapTranslator
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+return require("JSONTranslator").new("en", "InputKeyMapTranslator", {})

package/src/Server/InputKeyMapService.lua

@@ -0,0 +1,18 @@
+--[=[
+	@class InputKeyMapService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InputKeyMapService = {}
+InputKeyMapService.ServiceName = "InputKeyMapService"
+
+function InputKeyMapService:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	-- Internal
+	self._serviceBag:GetService(require("InputKeyMapRegistryServiceShared"))
+end
+
+return InputKeyMapService

package/src/{Client → Shared}/InputKeyMap.lua

@@ -11,21 +11,23 @@ local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
 local ValueObject = require("ValueObject")
-local InputMode = require("InputMode")
+local InputModeType = require("InputModeType")
 
 local InputKeyMap = setmetatable({}, BaseObject)
 InputKeyMap.ClassName = "InputKeyMap"
 InputKeyMap.__index = InputKeyMap
 
-function InputKeyMap.new(inputMode, inputTypes)
-	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+function InputKeyMap.new(inputModeType, inputTypes)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 	assert(type(inputTypes) == "table" or inputTypes == nil, "Bad inputTypes")
 
 	local self = setmetatable(BaseObject.new(), InputKeyMap)
 
-	self._inputMode = assert(inputMode, "No inputMode")
+	self._inputModeType = assert(inputModeType, "No inputModeType")
 
-	self._inputType = ValueObject.new(inputTypes or {})
+	self._defaultInputTypes = inputTypes or {}
+
+	self._inputType = ValueObject.new(self._defaultInputTypes)
 	self._maid:GiveTask(self._inputType)
 
 	return self
@@ -34,8 +36,8 @@ end
 --[=[
 	Gets the input mode for this keymap. This will not change.
 ]=]
-function InputKeyMap:GetInputMode()
-	return self._inputMode
+function InputKeyMap:GetInputModeType()
+	return self._inputModeType
 end
 
 function InputKeyMap:SetInputTypesList(inputTypes)
@@ -44,6 +46,14 @@ function InputKeyMap:SetInputTypesList(inputTypes)
 	self._inputType.Value = inputTypes
 end
 
+function InputKeyMap:GetDefaultInputTypesList()
+	return self._defaultInputTypes
+end
+
+function InputKeyMap:RestoreDefault()
+	self._inputType.Value = self._defaultInputTypes
+end
+
 function InputKeyMap:ObserveInputTypesList()
 	return self._inputType:Observe()
 end

package/src/{Client → Shared}/InputKeyMapList.lua

@@ -8,9 +8,9 @@
 
 	```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") });
+		InputKeyMap.new(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.LeftControl });
+		InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.ButtonX });
+		InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary1") });
 	})
 
 	maid:GiveTask(Rx.combineLatest({
@@ -40,20 +40,19 @@
 
 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 Brio = require("Brio")
+local InputKeyMap = require("InputKeyMap")
+local InputModeType = require("InputModeType")
+local InputTypeUtils = require("InputTypeUtils")
 local Maid = require("Maid")
-local Rx = require("Rx")
 local ObservableCountingMap = require("ObservableCountingMap")
-local InputMode = require("InputMode")
-local SlottedTouchButtonUtils = require("SlottedTouchButtonUtils")
+local ObservableMap = require("ObservableMap")
+local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
-local Brio = require("Brio")
+local SlottedTouchButtonUtils = require("SlottedTouchButtonUtils")
 local StateStack = require("StateStack")
-local InputTypeUtils = require("InputTypeUtils")
+local String = require("String")
 
 local InputKeyMapList = setmetatable({}, BaseObject)
 InputKeyMapList.ClassName = "InputKeyMapList"
@@ -64,15 +63,17 @@ InputKeyMapList.__index = InputKeyMapList
 
 	@param inputMapName string
 	@param inputKeyMapList { InputKeyMap }
+	@param options { bindingName: string, rebindable: boolean } -- configuration options
 	@return InputKeyMapList
 ]=]
-function InputKeyMapList.new(inputMapName, inputKeyMapList)
+function InputKeyMapList.new(inputMapName, inputKeyMapList, options)
 	local self = setmetatable(BaseObject.new(), InputKeyMapList)
 
 	self._inputKeyMapListName = assert(inputMapName, "No inputMapName")
+	self._options = assert(options, "No options")
 
-	self._inputModeToInputKeyMap = ObservableMap.new()
-	self._maid:GiveTask(self._inputModeToInputKeyMap)
+	self._inputModeTypeToInputKeyMap = ObservableMap.new()
+	self._maid:GiveTask(self._inputModeTypeToInputKeyMap)
 
 	for _, inputKeyMap in pairs(inputKeyMapList) do
 		self:Add(inputKeyMap)
@@ -91,6 +92,26 @@ function InputKeyMapList.isInputKeyMapList(value)
 	return type(value) == "table" and getmetatable(value) == InputKeyMapList
 end
 
+--[=[
+	Returns user bindable time
+	@return boolean
+]=]
+function InputKeyMapList:IsUserRebindable()
+	return self._options.rebindable == true
+end
+
+--[=[
+	Gets the english name
+	@return string
+]=]
+function InputKeyMapList:GetBindingName()
+	return self._options.bindingName
+end
+
+function InputKeyMapList:GetBindingTranslationKey()
+	return "keybinds." .. String.toCamelCase(self._inputKeyMapListName)
+end
+
 --[=[
 	Adds an input key map into the actual list
 	@param inputKeyMap InputKeyMap
@@ -98,8 +119,8 @@ end
 function InputKeyMapList:Add(inputKeyMap)
 	assert(inputKeyMap, "Bad inputKeyMap")
 
-	self._maid[inputKeyMap:GetInputMode()] = inputKeyMap
-	self._inputModeToInputKeyMap:Set(inputKeyMap:GetInputMode(), inputKeyMap)
+	self._maid[inputKeyMap:GetInputModeType()] = inputKeyMap
+	self._inputModeTypeToInputKeyMap:Set(inputKeyMap:GetInputModeType(), inputKeyMap)
 end
 
 --[=[
@@ -110,17 +131,17 @@ function InputKeyMapList:GetListName()
 	return self._inputKeyMapListName
 end
 
-function InputKeyMapList:SetInputTypesList(inputMode, inputTypes)
-	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+function InputKeyMapList:SetInputTypesList(inputModeType, inputTypes)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 	assert(type(inputTypes) == "table" or inputTypes == nil, "Bad inputTypes")
 
 	if inputTypes == nil then
-		self._inputModeToInputKeyMap:Remove(inputMode)
-		self._maid[inputMode] = nil
+		self._inputModeTypeToInputKeyMap:Remove(inputModeType)
+		self._maid[inputModeType] = nil
 	else
-		local inputKeyMap = self._inputModeToInputKeyMap:Get(inputMode)
+		local inputKeyMap = self._inputModeTypeToInputKeyMap:Get(inputModeType)
 		if not inputKeyMap then
-			self:Add(InputKeyMap.new(inputMode, inputTypes))
+			self:Add(InputKeyMap.new(inputModeType, inputTypes))
 		else
 			inputKeyMap:SetInputTypesList(inputTypes)
 		end
@@ -128,98 +149,57 @@ function InputKeyMapList:SetInputTypesList(inputMode, inputTypes)
 end
 
 --[=[
-	Removes the entry for the inputmode
-
-	@param inputMode InputMode
+	Observes a brio with the first value as the InputModeType and the second value as the KeyMapList
+	@return Observable<Brio<InputModeType, InputKeyMap>>
 ]=]
-function InputKeyMapList:RemoveInputMode(inputMode)
-	assert(InputMode.isInputMode(inputMode), "Bad inputMode")
+function InputKeyMapList:ObservePairsBrio()
+	return self._inputModeTypeToInputKeyMap:ObservePairsBrio()
+end
 
-	self:SetInputTypesList(inputMode, nil)
+--[=[
+	Restores the default value for all lists
+]=]
+function InputKeyMapList:RestoreDefault()
+	for _, item in pairs(self._inputModeTypeToInputKeyMap:GetValueList()) do
+		item:RestoreDefault()
+	end
 end
 
 --[=[
-	Observes the input enums list
+	Removes the entry for the inputmodeType
 
-	@return InputModeSelector
+	@param inputModeType InputModeType
 ]=]
-function InputKeyMapList:GetNewInputModeSelector()
-	return InputModeSelector.fromObservableBrio(self:ObserveInputModesBrio())
+function InputKeyMapList:RemoveInputModeType(inputModeType)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
+
+	self:SetInputTypesList(inputModeType, nil)
 end
 
 --[=[
 	@return Observable<Brio<InputKeyMap>>
 ]=]
 function InputKeyMapList:ObserveInputKeyMapsBrio()
-	return self._inputModeToInputKeyMap:ObserveValuesBrio()
+	return self._inputModeTypeToInputKeyMap:ObserveValuesBrio()
 end
 
 --[=[
-	@return Observable<Brio<InputMode>>
+	@return Observable<Brio<InputModeType>>
 ]=]
-function InputKeyMapList:ObserveInputModesBrio()
-	return self._inputModeToInputKeyMap:ObserveKeysBrio()
+function InputKeyMapList:ObserveInputModesTypesBrio()
+	return self._inputModeTypeToInputKeyMap:ObserveKeysBrio()
 end
 
 --[=[
 	Observes the input types for the active input map
 
+	@param inputModeType InputModeType
 	@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)
+function InputKeyMapList:ObserveInputKeyMapForInputMode(inputModeType)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
-		return maid
-	end)
+	return self._inputModeTypeToInputKeyMap:ObserveValueForKey(inputModeType)
 end
 
 --[=[
@@ -294,14 +274,14 @@ end
 	@return Observable<SlottedTouchButton>
 ]=]
 function InputKeyMapList:ObserveSlottedTouchButtonDataBrio()
-	return self._inputModeToInputKeyMap:ObservePairsBrio():Pipe({
-		RxBrioUtils.flatMapBrio(function(inputMode, inputKeyMap)
+	return self._inputModeTypeToInputKeyMap:ObservePairsBrio():Pipe({
+		RxBrioUtils.flatMapBrio(function(inputModeType, 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)
+							local data = SlottedTouchButtonUtils.createTouchButtonData(inputType.slotId, inputModeType)
 							table.insert(valid, Brio.new(data))
 						end
 					end
@@ -332,7 +312,7 @@ function InputKeyMapList:_ensureInit()
 	self._maid:GiveTask(self._isRobloxTouchButton)
 
 	-- Listen
-	self._maid:GiveTask(self._inputModeToInputKeyMap:ObserveValuesBrio():Subscribe(function(brio)
+	self._maid:GiveTask(self._inputModeTypeToInputKeyMap:ObserveValuesBrio():Subscribe(function(brio)
 		if brio:IsDead() then
 			return
 		end

package/src/{Client → Shared}/InputKeyMapListProvider.lua

@@ -6,19 +6,28 @@
 	```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") });
+			InputKeyMap.new(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.Space });
+			InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.ButtonA });
+			InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary3") });
+		}, {
+			bindingName = "Jump";
+			rebindable = true;
 		}))
 		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") });
+			InputKeyMap.new(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.H });
+			InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.DPadUp });
+			InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary2") });
+		}, {
+			bindingName = "Honk";
+			rebindable = true;
 		}))
 		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") });
+			InputKeyMap.new(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.LeftControl });
+			InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.ButtonX });
+			InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary4") });
+		}, {
+			bindingName = "Boost";
+			rebindable = true;
 		}))
 	end)
 
@@ -36,10 +45,12 @@ local require = require(script.Parent.loader).load(script)
 local RunService = game:GetService("RunService")
 
 local Maid = require("Maid")
-local InputKeyMapServiceClient = require("InputKeyMapServiceClient")
+local InputKeyMapRegistryServiceShared = require("InputKeyMapRegistryServiceShared")
+local ObservableList = require("ObservableList")
 
 local InputKeyMapListProvider = {}
 InputKeyMapListProvider.ClassName = "InputKeyMapListProvider"
+InputKeyMapListProvider.ServiceName = "InputKeyMapListProvider"
 InputKeyMapListProvider.__index = InputKeyMapListProvider
 
 --[=[
@@ -55,11 +66,30 @@ function InputKeyMapListProvider.new(providerName, createDefaults)
 	local self = setmetatable({}, InputKeyMapListProvider)
 
 	self._providerName = assert(providerName, "No providerName")
+	self.ServiceName = providerName
 	self._createDefaults = assert(createDefaults, "No createDefaults")
 
 	return self
 end
 
+function InputKeyMapListProvider:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+
+	self._inputMapLists = ObservableList.new()
+	self._maid:GiveTask(self._inputMapLists)
+
+	self._maid:GiveTask(self._serviceBag:GetService(InputKeyMapRegistryServiceShared):RegisterProvider(self))
+
+	self:_ensureDefaultsInit()
+end
+
+function InputKeyMapListProvider:Start()
+	-- empty function
+end
+
 --[=[
 	Gets this providers name
 	@return string
@@ -92,16 +122,17 @@ end
 function InputKeyMapListProvider:FindInputKeyMapList(keyMapListName)
 	assert(type(keyMapListName) == "string", "Bad keyMapListName")
 
+	if RunService:IsRunning() and not self._inputKeyMapLists then
+		error("Not initialized, make sure to retrieve via serviceBag and init")
+	end
+
+	-- Test mode initialize
 	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
+		self._maid = Maid.new()
 	end
 
+	self:_ensureDefaultsInit()
+
 	return self._inputKeyMapLists[keyMapListName]
 end
 
@@ -115,16 +146,12 @@ function InputKeyMapListProvider:Add(inputKeyMapList)
 
 	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._maid:GiveTask(self._inputMapLists:Add(inputKeyMapList))
+end
 
-	self:_ensureDefaultsInit()
+function InputKeyMapListProvider:ObserveInputKeyMapListsBrio()
+	return self._inputMapLists:ObserveItemsBrio()
 end
 
 function InputKeyMapListProvider:_ensureDefaultsInit()
@@ -135,10 +162,6 @@ function InputKeyMapListProvider:_ensureDefaultsInit()
 	end
 end
 
-function InputKeyMapListProvider:Start()
-	-- empty function
-end
-
 function InputKeyMapListProvider:Destroy()
 	if self._maid then
 		self._maid:DoCleaning()

package/src/Shared/InputKeyMapRegistryServiceShared.lua

@@ -0,0 +1,112 @@
+--[=[
+	Provides retrieval of input key maps across the game. Available on both the client and the server.
+
+	Input key maps are needed on the server to bind datastore settings.
+
+	@class InputKeyMapRegistryServiceShared
+]=]
+
+local RunService = game:GetService("RunService")
+
+local require = require(script.Parent.loader).load(script)
+
+local Maid = require("Maid")
+local ObservableList = require("ObservableList")
+local RxBrioUtils = require("RxBrioUtils")
+
+local InputKeyMapRegistryServiceShared = {}
+InputKeyMapRegistryServiceShared.ServiceName = "InputKeyMapRegistryServiceShared"
+
+function InputKeyMapRegistryServiceShared:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+
+	self._providerLookupByName = {}
+
+	self._providersList = ObservableList.new()
+	self._maid:GiveTask(self._providersList)
+
+	self._maid:GiveTask(self._providersList:ObserveItemsBrio():Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local maid = brio:ToMaid()
+		local provider = brio:GetValue()
+
+		local providerName = provider:GetProviderName()
+
+		if self._providerLookupByName[providerName] then
+			error(("Already have a provider with name %q"):format(providerName))
+		end
+
+		self._providerLookupByName[providerName] = provider
+
+		maid:GiveTask(function()
+			if self._providerLookupByName[providerName] == provider then
+				self._providerLookupByName[providerName] = nil
+			end
+		end)
+	end))
+end
+
+function InputKeyMapRegistryServiceShared:RegisterProvider(provider)
+	assert(provider, "Bad provider")
+	assert(self._providersList, "Not initialized")
+
+	return self._providersList:Add(provider)
+end
+
+function InputKeyMapRegistryServiceShared:ObserveProvidersBrio()
+	return self._providersList:ObserveItemsBrio()
+end
+
+function InputKeyMapRegistryServiceShared:ObserveInputKeyMapListsBrio()
+	return self:ObserveProvidersBrio():Pipe({
+		RxBrioUtils.flatMapBrio(function(provider)
+			return provider:ObserveInputKeyMapListsBrio()
+		end)
+	})
+end
+
+function InputKeyMapRegistryServiceShared:GetProvider(providerName)
+	assert(type(providerName) == "string", "Bad providerName")
+
+	return self._providerLookupByName[providerName]
+end
+
+-- function InputKeyMapRegistryServiceShared:ObserveInputKeyMapList(providerName, inputKeyMapListName)
+-- 	assert(type(providerName) == "string", "Bad providerName")
+-- 	assert(type(inputKeyMapListName) == "string", "Bad inputKeyMapListName")
+
+-- end
+
+function InputKeyMapRegistryServiceShared: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._providersList, "Not initialized")
+
+	for _, provider in pairs(self._providerLookupByName) do
+		if provider:GetProviderName() == providerName then
+			local found = provider:FindInputKeyMapList(inputKeyMapListName)
+			if found then
+				return found
+			end
+		end
+	end
+
+	return nil
+end
+
+function InputKeyMapRegistryServiceShared:Destroy()
+	self._maid:DoCleaning()
+end
+
+
+return InputKeyMapRegistryServiceShared

package/src/{Client → Shared}/ProximityPromptInputUtils.lua

@@ -7,8 +7,9 @@
 local require = require(script.Parent.loader).load(script)
 
 local InputKeyMapList = require("InputKeyMapList")
-local INPUT_MODES = require("INPUT_MODES")
+local InputModeTypes = require("InputModeTypes")
 local InputKeyMap = require("InputKeyMap")
+local InputModeType = require("InputModeType")
 
 local ProximityPromptInputUtils = {}
 
@@ -22,8 +23,11 @@ function ProximityPromptInputUtils.newInputKeyMapFromPrompt(prompt)
 	assert(typeof(prompt) == "Instance", "Bad prompt")
 
 	return InputKeyMapList.new("custom", {
-		InputKeyMap.new(INPUT_MODES.Gamepads, { prompt.GamepadKeyCode });
-		InputKeyMap.new(INPUT_MODES.Keyboard, { prompt.KeyboardKeyCode })
+		InputKeyMap.new(InputModeTypes.Gamepads, { prompt.GamepadKeyCode });
+		InputKeyMap.new(InputModeTypes.Keyboard, { prompt.KeyboardKeyCode })
+	}, {
+		bindingName = prompt.ActionText;
+		rebindable = false;
 	})
 end
 
@@ -38,8 +42,8 @@ function ProximityPromptInputUtils.configurePromptFromInputKeyMap(prompt, inputK
 	assert(typeof(prompt) == "Instance", "Bad prompt")
 	assert(type(inputKeyMapList) == "table", "Bad inputKeyMapList")
 
-	local keyboard = ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, INPUT_MODES.Keyboard)
-	local gamepad = ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, INPUT_MODES.Gamepads)
+	local keyboard = ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, InputModeTypes.Keyboard)
+	local gamepad = ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, InputModeTypes.Gamepads)
 
 	if keyboard then
 		prompt.KeyboardKeyCode = keyboard
@@ -51,21 +55,21 @@ function ProximityPromptInputUtils.configurePromptFromInputKeyMap(prompt, inputK
 end
 
 --[=[
-	Picks the first keyCode that matches the inputMode.
+	Picks the first keyCode that matches the inputModeType.
 
 	@param inputKeyMapList InputKeyMapList
-	@param inputMode InputMode
+	@param inputModeType InputModeType
 	@return KeyCode?
 ]=]
-function ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, inputMode)
+function ProximityPromptInputUtils.getFirstInputKeyCode(inputKeyMapList, inputModeType)
 	assert(type(inputKeyMapList) == "table", "Bad inputKeyMapList")
-	assert(inputMode, "Bad inputMode")
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
 	for _, item in pairs(inputKeyMapList) do
 		for _, entry in pairs(item.inputTypes) do
 			if typeof(entry) == "EnumItem"
 				and entry.EnumType == Enum.KeyCode
-				and inputMode:IsValid(entry) then
+				and inputModeType:IsValid(entry) then
 
 				return entry
 			end

package/src/{Client → Shared}/Types/InputTypeUtils.lua

@@ -10,10 +10,20 @@ local InputTypeUtils = {}
 
 --[=[
 	A valid input type that can be represented here.
-	@type InputType KeyCode | UserInputType | SlottedTouchButton | "TouchButton" | "Tap" | any
+	@type InputType KeyCode | UserInputType | SlottedTouchButton | "TouchButton" | "Tap" | "Drag" | any
 	@within InputTypeUtils
 ]=]
 
+function InputTypeUtils.isKnownInputType(inputType)
+	return InputTypeUtils.isTapInWorld(inputType)
+		or InputTypeUtils.isRobloxTouchButton(inputType)
+		or InputTypeUtils.isDrag(inputType)
+		or SlottedTouchButtonUtils.isSlottedTouchButton(inputType)
+		or (typeof(inputType) == "EnumItem" and (
+			tostring(inputType.EnumType) == "UserInputType"
+			or tostring(inputType.EnumType) == "KeyCode"))
+end
+
 --[=[
 	Returns true if the input type is specifying a tap in the world
 	@param inputKey any
@@ -23,6 +33,16 @@ function InputTypeUtils.isTapInWorld(inputKey)
 	return inputKey == "Tap"
 end
 
+
+--[=[
+	Returns true if the input type is specifying a drag
+	@param inputKey any
+	@return boolean
+]=]
+function InputTypeUtils.isDrag(inputKey)
+	return inputKey == "Drag"
+end
+
 --[=[
 	Returns true if the input type is specifying a Roblox touch button
 	@param inputKey any

package/src/{Client → Shared}/Types/SlottedTouchButtonUtils.lua

@@ -2,13 +2,17 @@
 	@class SlottedTouchButtonUtils
 ]=]
 
+local require = require(script.Parent.loader).load(script)
+
+local InputModeType = require("InputModeType")
+
 local SlottedTouchButtonUtils = {}
 
 --[=[
 	Internal data representing a slotted touch button
 	@interface SlottedTouchButtonData
 	.slotId string
-	.inputMode InputMode
+	.inputModeType InputModeType
 	@within SlottedTouchButtonUtils
 ]=]
 
@@ -58,13 +62,13 @@ end
 	Gets slotted touch button data for an inputKeyMapList
 
 	@param slotId string
-	@param inputMode InputMode
+	@param inputModeType InputModeType
 	@return SlottedTouchButtonData
 ]=]
-function SlottedTouchButtonUtils.createTouchButtonData(slotId, inputMode)
+function SlottedTouchButtonUtils.createTouchButtonData(slotId, inputModeType)
 	return {
 		slotId = slotId;
-		inputMode = inputMode;
+		inputModeType = inputModeType;
 	}
 end
 
@@ -78,13 +82,13 @@ function SlottedTouchButtonUtils.getSlottedTouchButtonData(inputKeyMapList)
 	local slottedTouchButtons = {}
 
 	for _, inputKeyMap in pairs(inputKeyMapList) do
-		assert(inputKeyMap.inputMode, "Bad inputKeyMap.inputMode")
+		assert(InputModeType.isInputModeType(inputKeyMap.inputModeType), "Bad inputKeyMap.inputModeType")
 		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))
+					touchButtonData.slotId, inputKeyMap.inputModeType))
 			end
 		end
 	end

package/test/modules/Shared/TestInputKeyMap.lua

@@ -0,0 +1,31 @@
+--[=[
+	Test input key map provider
+	@class TestInputKeyMap
+]=]
+local require = require(script.Parent.loader).load(script)
+
+local InputModeTypes = require("InputModeTypes")
+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(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.Q });
+		InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.ButtonY });
+		InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary3") });
+	}, {
+		bindingName = "Jump";
+		rebindable = true;
+	}))
+
+	self:Add(InputKeyMapList.new("HONK", {
+		InputKeyMap.new(InputModeTypes.KeyboardAndMouse, { Enum.KeyCode.H });
+		InputKeyMap.new(InputModeTypes.Gamepads, { Enum.KeyCode.ButtonL1 });
+		InputKeyMap.new(InputModeTypes.Touch, { SlottedTouchButtonUtils.createSlottedTouchButton("primary2") });
+	}, {
+		bindingName = "Honk";
+		rebindable = true;
+	}))
+end)

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

@@ -5,7 +5,7 @@ local packages = game:GetService("ReplicatedStorage"):WaitForChild("Packages")
 
 local ContextActionService = game:GetService("ContextActionService")
 
-local INPUT_MODES = require(packages.INPUT_MODES)
+local InputModeTypes = require(packages.InputModeTypes)
 local serviceBag = require(packages.ServiceBag).new()
 
 serviceBag:GetService(packages.InputKeyMapServiceClient)
@@ -25,4 +25,4 @@ keyMapList:ObserveInputEnumsList():Subscribe(function(...)
 end)
 
 
-keyMapList:SetForInputMode(INPUT_MODES.Keypad, { Enum.KeyCode.Space })
+keyMapList:SetForInputMode(InputModeTypes.Keypad, { Enum.KeyCode.Space })

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

@@ -4,4 +4,13 @@
 local ServerScriptService = game:GetService("ServerScriptService")
 
 local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
-require(loader).bootstrapGame(ServerScriptService.inputkeymaputils)
+local packages = require(loader).bootstrapGame(ServerScriptService.inputkeymaputils)
+
+local serviceBag = require(packages.ServiceBag).new()
+
+serviceBag:GetService(packages.TestInputKeyMap)
+
+-- Start game
+serviceBag:Init()
+serviceBag:Start()
+

package/test/modules/Client/TestInputKeyMap.lua

@@ -1,25 +0,0 @@
---[=[
-	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)