@quenty/inputmode 5.2.0 → 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/inputmode@5.2.0...@quenty/inputmode@6.0.0) (2022-08-14)
+
+**Note:** Version bump only for package @quenty/inputmode
+
+
+
+
+
 # [5.2.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputmode@5.1.0...@quenty/inputmode@5.2.0) (2022-07-31)
 
 **Note:** Version bump only for package @quenty/inputmode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/inputmode",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "description": "Trace input mode state and trigger changes correctly",
   "keywords": [
     "Roblox",
@@ -29,10 +29,10 @@
     "@quenty/maid": "^2.4.0",
     "@quenty/signal": "^2.2.0",
     "@quenty/table": "^3.1.0",
-    "@quenty/valueobject": "^5.2.0"
+    "@quenty/valueobject": "^6.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e31b3a35aa475bb5699a24898a8639e107165b36"
+  "gitHead": "dbb62609f980983cc32da90acfef13e30ed41113"
 }

package/src/Client/InputMode.lua

@@ -1,6 +1,6 @@
 --[=[
 	Trace input mode state and trigger changes correctly. See [InputModeSelector] for details
-	on how to select between these. See [INPUT_MODES] for predefined modes.
+	on how to select between these. See [InputModeTypeTypes] for predefined modes.
 
 	@class InputMode
 ]=]
@@ -26,23 +26,21 @@ InputMode.__index = InputMode
 InputMode.ClassName = "InputMode"
 
 --[=[
-	Constructs a new InputMode
+	Constructs a new InputMode. This inherits data from the name.
 
-	@param name string
-	@param typesAndInputModes { { UserInputType | KeyCode | string | InputMode } }
+	@param inputModeType InputModeType
 	@return InputMode
 ]=]
-function InputMode.new(name, typesAndInputModes)
+function InputMode.new(inputModeType)
 	local self = setmetatable({}, InputMode)
 
+	self._inputModeType = assert(inputModeType, "Bad inputModeType")
+
 	self._lastEnabled = 0
-	self._valid = {}
 
-	self.Name = name or "Unnamed"
+	self.Name = self._inputModeType.Name
 	self.Enabled = Signal.new()
 
-	self:_addValidTypesFromTable(typesAndInputModes)
-
 	return self
 end
 
@@ -63,34 +61,12 @@ function InputMode:GetLastEnabledTime()
 	return self._lastEnabled
 end
 
-function InputMode:_addValidTypesFromTable(keys)
-	for _, key in pairs(keys) do
-		if typeof(key) == "EnumItem" then
-			self._valid[key] = true
-		elseif type(key) == "table" then
-			self:_addInputMode(key)
-		end
-	end
-end
-
-function InputMode:_addInputMode(inputMode)
-	assert(inputMode.ClassName == "InputMode", "bad inputMode")
-
-	for key, _ in pairs(inputMode._valid) do
-		self._valid[key] = true
-	end
-end
-
 --[=[
 	Returns all keys defining the input mode.
 	@return { UserInputType | KeyCode | string }
 ]=]
 function InputMode:GetKeys()
-	local keys = {}
-	for key, _ in pairs(self._valid) do
-		table.insert(keys, key)
-	end
-	return keys
+	return self._inputModeType:GetKeys()
 end
 
 --[=[
@@ -101,7 +77,7 @@ end
 function InputMode:IsValid(inputType)
 	assert(inputType, "Must send in inputType")
 
-	return self._valid[inputType]
+	return self._inputModeType:IsValid(inputType)
 end
 
 --[=[
@@ -117,11 +93,18 @@ end
 	@param inputObject InputObject
 ]=]
 function InputMode:Evaluate(inputObject)
-	if self._valid[inputObject.UserInputType]
-		or self._valid[inputObject.KeyCode] then
+	if self._inputModeType:IsValid(inputObject.UserInputType)
+		or self._inputModeType:IsValid(inputObject.KeyCode) then
 
 		self:Enable()
 	end
 end
 
+--[=[
+	Cleans up the input mode
+]=]
+function InputMode:Destroy()
+	self.Enabled:Destroy()
+end
+
 return InputMode

package/src/Client/InputModeProcessor.lua

@@ -1,6 +1,5 @@
 --[=[
-	Process inputs by evaluating inputModes. Typically not used directly, but rather, just
-	use modes from INPUT_MODES.
+	Process inputs by evaluating inputModes. Helper object..
 
 	@class InputModeProcessor
 ]=]
@@ -11,7 +10,7 @@ InputModeProcessor.ClassName = InputModeProcessor
 
 --[=[
 	Construtcs a new inputModeProcessor
-	@param inputModes { InputMode }
+	@param inputModes { InputMode }?
 	@return InputModeProcessor
 ]=]
 function InputModeProcessor.new(inputModes)
@@ -19,13 +18,19 @@ function InputModeProcessor.new(inputModes)
 
 	self._inputModes = {}
 
-	for _, state in pairs(inputModes) do
-		self._inputModes[#self._inputModes+1] = state
+	if inputModes then
+		for _, inputMode in pairs(inputModes) do
+			self:AddInputMode(inputMode)
+		end
 	end
 
 	return self
 end
 
+function InputModeProcessor:AddInputMode(inputMode)
+	table.insert(self._inputModes, inputMode)
+end
+
 --[=[
 	Gets all input mode inputModes being used
 	@return { InputMode }

package/src/Client/InputModeServiceClient.lua

@@ -0,0 +1,115 @@
+--[=[
+	Centralized
+	@class InputModeServiceClient
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local UserInputService = game:GetService("UserInputService")
+local GuiService = game:GetService("GuiService")
+
+local InputModeType = require("InputModeType")
+local Maid = require("Maid")
+local InputModeProcessor = require("InputModeProcessor")
+local InputModeTypes = require("InputModeTypes")
+local InputMode = require("InputMode")
+
+local THUMBSTICK_DEADZONE = 0.14
+
+local InputModeServiceClient = {}
+InputModeServiceClient.ServiceName = "InputModeServiceClient"
+
+function InputModeServiceClient:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	self._maid = Maid.new()
+	self._inputModes = {}
+
+	self._inputModeProcessor = InputModeProcessor.new()
+
+	-- order semi-matters. general should come first, to non-specific. that way, specific stuff has
+	-- priority over non-specific input modes.
+	self:GetInputMode(InputModeTypes.KeyboardAndMouse);
+	self:GetInputMode(InputModeTypes.Gamepads);
+	self:GetInputMode(InputModeTypes.Keyboard);
+	self:GetInputMode(InputModeTypes.Touch);
+	self:GetInputMode(InputModeTypes.Mouse);
+	self:GetInputMode(InputModeTypes.ArrowKeys);
+	self:GetInputMode(InputModeTypes.Keypad);
+	self:GetInputMode(InputModeTypes.WASD);
+	self:GetInputMode(InputModeTypes.DPad);
+	-- Don't add InputModeTypes.Thumbsticks, we handle it seperately
+
+	self:_triggerEnabled()
+	self:_bindProcessor()
+end
+
+function InputModeServiceClient:GetInputMode(inputModeType)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
+
+	if self._inputModes[inputModeType] then
+		return self._inputModes[inputModeType]
+	end
+
+	local inputMode = InputMode.new(inputModeType)
+	self._maid:GiveTask(inputMode)
+
+	self._inputModes[inputModeType] = inputMode
+	return inputMode
+end
+
+function InputModeServiceClient:_triggerEnabled()
+	if UserInputService.MouseEnabled then
+		self:GetInputMode(InputModeTypes.Mouse):Enable()
+	end
+	if UserInputService.TouchEnabled then
+		self:GetInputMode(InputModeTypes.Touch):Enable()
+	end
+	if UserInputService.KeyboardEnabled then
+		self:GetInputMode(InputModeTypes.Keyboard):Enable()
+	end
+	if UserInputService.KeyboardEnabled and UserInputService.MouseEnabled then
+		self:GetInputMode(InputModeTypes.KeyboardAndMouse):Enable()
+	end
+	if UserInputService.GamepadEnabled
+		or #UserInputService:GetConnectedGamepads() > 0
+		or GuiService:IsTenFootInterface() then
+		self:GetInputMode(InputModeTypes.Gamepads):Enable()
+	end
+end
+
+function InputModeServiceClient:_bindProcessor()
+	self._maid:GiveTask(UserInputService.InputBegan:Connect(function(inputObject)
+		self._inputModeProcessor:Evaluate(inputObject)
+	end))
+	self._maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject)
+		self._inputModeProcessor:Evaluate(inputObject)
+	end))
+	self._maid:GiveTask(UserInputService.InputChanged:Connect(function(inputObject)
+		if inputObject.KeyCode == Enum.KeyCode.Thumbstick1
+			or inputObject.KeyCode == Enum.KeyCode.Thumbstick2 then
+
+			if inputObject.Position.magnitude > THUMBSTICK_DEADZONE then
+				self._inputModeProcessor:Evaluate(inputObject)
+				self:GetInputMode(InputModeTypes.Thumbsticks):Enable()
+			end
+		else
+			self._inputModeProcessor:Evaluate(inputObject)
+		end
+	end))
+
+	self._maid:GiveTask(UserInputService.GamepadConnected:Connect(function(_)
+		self:GetInputMode(InputModeTypes.Gamepads):Enable()
+	end))
+
+	self._maid:GiveTask(UserInputService.GamepadDisconnected:Connect(function(_)
+		self:_triggerEnabled()
+	end))
+end
+
+function InputModeServiceClient:Destroy()
+	self._maid:DoCleaning()
+end
+
+return InputModeServiceClient

package/src/Client/InputModeTypeSelector.lua

@@ -0,0 +1,242 @@
+--[=[
+	Selects the most recent input mode and attempts to identify the best state from it.
+	@class InputModeTypeSelector
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InputModeTypes = require("InputModeTypes")
+local Maid = require("Maid")
+local ValueObject = require("ValueObject")
+local InputModeServiceClient = require("InputModeServiceClient")
+local ServiceBag = require("ServiceBag")
+
+local InputModeTypeSelector = {}
+InputModeTypeSelector.ClassName = "InputModeTypeSelector"
+InputModeTypeSelector.DEFAULT_MODE_TYPES = {
+	InputModeTypes.Gamepads,
+	InputModeTypes.Keyboard,
+	InputModeTypes.Touch
+}
+
+--[=[
+	Constructs a new InputModeTypeSelector
+
+	@param serviceBag ServiceBag
+	@param inputModesTypes { InputModeType }
+	@return InputModeTypeSelector
+]=]
+function InputModeTypeSelector.new(serviceBag, inputModesTypes)
+	local self = setmetatable({}, InputModeTypeSelector)
+
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	self._inputModeServiceClient = self._serviceBag:GetService(InputModeServiceClient)
+
+	self._maid = Maid.new()
+
+	-- keep this ordered so we are always stable in selection.
+	self._inputModeTypeList = {}
+
+	self._activeModeType = ValueObject.new()
+	self._maid:GiveTask(self._activeModeType)
+
+--[=[
+	Event that fires whenever the active mode changes.
+	@prop Changed Signal<InputModeType, InputModeType> -- newMode, oldMode
+	@within InputModeTypeSelector
+]=]
+	self.Changed = self._activeModeType.Changed
+
+	for _, inputModeType in pairs(inputModesTypes or InputModeTypeSelector.DEFAULT_MODE_TYPES) do
+		self:AddInputModeType(inputModeType)
+	end
+
+	return self
+end
+
+--[=[
+	Constructs a new InputModeTypeSelector
+
+	@param serviceBag ServiceBag
+	@param observeInputModesBrio Observable<Brio<InputModeType>>
+	@return InputModeTypeSelector
+]=]
+function InputModeTypeSelector.fromObservableBrio(serviceBag, observeInputModesBrio)
+	local selector = InputModeTypeSelector.new(serviceBag, {})
+
+	selector._maid:GiveTask(observeInputModesBrio:Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local inputModeType = brio:GetValue()
+		local maid = brio:ToMaid()
+		selector:AddInputModeType(inputModeType)
+
+		maid:GiveTask(function()
+			if selector.Destroy then
+				selector:RemoveInputModeType(inputModeType)
+			end
+		end)
+	end))
+
+	return selector
+end
+
+--[=[
+	Returns the current active mode
+	@return InputModeType
+]=]
+function InputModeTypeSelector:GetActiveInputType()
+	return rawget(self, "_activeModeType").Value
+end
+
+--[=[
+	Observes the current active mode
+	@return Observable<InputModeType>
+]=]
+function InputModeTypeSelector:ObserveActiveInputType()
+	return rawget(self, "_activeModeType"):Observe()
+end
+
+--[=[
+	The current active input mode
+	@prop Value InputModeType?
+	@within InputModeTypeSelector
+]=]
+function InputModeTypeSelector:__index(index)
+	if index == "Value" then
+		return rawget(self, "_activeModeType").Value
+	elseif InputModeTypeSelector[index] then
+		return InputModeTypeSelector[index]
+	else
+		local value = rawget(self, index)
+		if value then
+			return value
+		else
+			error(("[InputModeTypeSelector] - Bad index '%s'"):format(tostring(index)))
+		end
+	end
+end
+
+--[=[
+	Binds the updateBindFunction to the mode selector
+
+	```lua
+	local inputModeTypeSelector = InputModeTypeSelector.new({
+		InputModeTypes.Mouse;
+		InputModeTypes.Touch;
+	})
+
+	inputModeTypeSelector:Bind(function(inputModeType)
+		if inputModeType == InputModeTypes.Mouse then
+			print("Show mouse input hints")
+		elseif inputModeType == InputModeTypes.Touch then
+			print("Show touch input hints")
+		else
+			-- Unknown input mode
+			warn("Unknown input mode") -- should not occur
+		end
+	end)
+	```
+
+	@param updateBindFunction (newMode: InputModeType, modeMaid: Maid) -> ()
+	@return InputModeTypeSelector
+]=]
+function InputModeTypeSelector:Bind(updateBindFunction)
+	local maid = Maid.new()
+	self._maid[updateBindFunction] = maid
+
+	local function onChange(newMode, _)
+		maid._modeMaid = nil
+
+		if newMode then
+			local modeMaid = Maid.new()
+			maid._modeMaid = modeMaid
+
+			if newMode then
+				updateBindFunction(newMode, modeMaid)
+			end
+		end
+	end
+
+	maid:GiveTask(self._activeModeType.Changed:Connect(onChange))
+	onChange(self._activeModeType.Value, nil)
+
+	return self
+end
+
+--[=[
+	Removes the input mode
+	@param inputModeType InputModeType
+]=]
+function InputModeTypeSelector:RemoveInputModeType(inputModeType)
+	if not self._maid[inputModeType] then
+		return
+	end
+
+	local index = table.find(self._inputModeTypeList, inputModeType)
+	if index then
+		table.remove(self._inputModeTypeList, index)
+	else
+		warn("[InputModeTypeSelector] - Failed to find inputModeType")
+	end
+
+	self._maid[inputModeType] = nil
+
+	if self._activeModeType.Value == inputModeType then
+		self:_pickNewInputMode()
+	end
+end
+
+--[=[
+	Adds a new input mode
+	@param inputModeType InputModeType
+]=]
+function InputModeTypeSelector:AddInputModeType(inputModeType)
+	if self._maid[inputModeType] then
+		return
+	end
+
+	table.insert(self._inputModeTypeList, inputModeType)
+	local inputMode = self._inputModeServiceClient:GetInputMode(inputModeType)
+	self._maid[inputModeType] = inputMode.Enabled:Connect(function()
+		self._activeModeType.Value = inputModeType
+	end)
+
+	if not self._activeModeType.Value
+		or inputMode:GetLastEnabledTime() > self._inputModeServiceClient:GetInputMode(self._activeModeType.Value):GetLastEnabledTime() then
+		self._activeModeType.Value = inputModeType
+	end
+end
+
+function InputModeTypeSelector:_pickNewInputMode()
+	local bestEnabledTime = -math.huge
+	local bestModeType
+	for _, inputModeType in pairs(self._inputModeTypeList) do
+		local enableTime = self._inputModeServiceClient:GetInputMode(inputModeType):GetLastEnabledTime()
+		if enableTime >= bestEnabledTime then
+			bestEnabledTime = enableTime
+			bestModeType = inputModeType
+		end
+	end
+
+	self._activeModeType.Value = bestModeType
+end
+
+--[=[
+	Cleans up the input mode selector.
+
+	:::info
+	This should be called whenever the mode selector is done being used.
+	:::
+]=]
+function InputModeTypeSelector:Destroy()
+	self._maid:DoCleaning()
+	setmetatable(self, nil)
+end
+
+return InputModeTypeSelector

package/src/Shared/InputModeType.lua

@@ -0,0 +1,81 @@
+--[=[
+	Type specification for input modes, which is static. Separated out from InputMode which is dynamic.
+
+	@class InputModeType
+]=]
+
+local InputModeType = {}
+InputModeType.ClassName = "InputModeType"
+InputModeType.__index = InputModeType
+
+--[=[
+	Constructs a new InputModeType
+
+	@param name string
+	@param typesAndInputModes { { UserInputType | KeyCode | string | InputMode } }
+	@return InputMode
+]=]
+function InputModeType.new(name, typesAndInputModes)
+	local self = setmetatable({}, InputModeType)
+
+	self._valid = {}
+	self.Name = name or "Unnamed"
+
+	self:_addValidTypesFromTable(typesAndInputModes)
+
+	return self
+end
+
+--[=[
+	Returns true if a given value is an InputModeType
+	@param value any
+	@return boolean
+]=]
+function InputModeType.isInputModeType(value)
+	return type(value) == "table" and getmetatable(value) == InputModeType
+end
+
+--[=[
+	Checks the validity of the inputType
+	@param inputType { UserInputType | KeyCode | string }
+	@return boolean
+]=]
+function InputModeType:IsValid(inputType)
+	assert(inputType, "Must send in inputType")
+
+	return self._valid[inputType]
+end
+
+--[=[
+	Returns all keys defining the input mode.
+	@return { UserInputType | KeyCode | string }
+]=]
+function InputModeType:GetKeys()
+	local keys = {}
+	for key, _ in pairs(self._valid) do
+		table.insert(keys, key)
+	end
+	return keys
+end
+
+function InputModeType:_addValidTypesFromTable(keys)
+	for _, key in pairs(keys) do
+		if typeof(key) == "EnumItem" then
+			self._valid[key] = true
+		elseif InputModeType.isInputModeType(key) then
+			self:_addInputModeType(key)
+		end
+	end
+end
+
+function InputModeType:_addInputModeType(inputModeType)
+	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
+
+	for key, _ in pairs(inputModeType._valid) do
+		self._valid[key] = true
+	end
+end
+
+
+
+return InputModeType

package/src/{Client/INPUT_MODES.lua → Shared/InputModeTypes.lua}

@@ -1,31 +1,22 @@
 --[=[
-	Holds input states for Keyboard, Mouse, et cetera. Mostly useful for providing UI input hints to the user by
-	identifying the most recent input state provided. See [InputMode] for more details, and [InputModeSelector] for
-	how to select between several modes.
-
-	@class INPUT_MODES
+	Holds all the input mode type configuration, accessible on both the server and the client for keybinding validations.
+	@class InputModeTypes
 ]=]
 
-local UserInputService = game:GetService("UserInputService")
-local GuiService = game:GetService("GuiService")
-
 local require = require(script.Parent.loader).load(script)
 
-local InputMode = require("InputMode")
-local InputModeProcessor = require("InputModeProcessor")
 local Table = require("Table")
+local InputModeType = require("InputModeType")
 
-local INPUT_MODES = {
-	THUMBSTICK_DEADZONE = 0.14
-}
+local InputModeTypes = {}
 
 --[=[
 	Input from a keypad
-	@prop Keypad InputMode
+	@prop Keypad InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Keypad = InputMode.new("Keypad", {
+InputModeTypes.Keypad = InputModeType.new("Keypad", {
 	Enum.KeyCode.KeypadZero;
 	Enum.KeyCode.KeypadOne;
 	Enum.KeyCode.KeypadTwo;
@@ -47,15 +38,15 @@ INPUT_MODES.Keypad = InputMode.new("Keypad", {
 
 --[=[
 	Input from a keyboard
-	@prop Keyboard InputMode
+	@prop Keyboard InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Keyboard = InputMode.new("Keyboard", {
+InputModeTypes.Keyboard = InputModeType.new("Keyboard", {
 	Enum.UserInputType.Keyboard;
 
 	-- Other input modes
-	INPUT_MODES.Keypad;
+	InputModeTypes.Keypad;
 
 	-- Valid KeyCodes for input binding
 	Enum.KeyCode.Backspace;
@@ -184,11 +175,11 @@ INPUT_MODES.Keyboard = InputMode.new("Keyboard", {
 
 --[=[
 	Input involving arrow keys!
-	@prop ArrowKeys InputMode
+	@prop ArrowKeys InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.ArrowKeys = InputMode.new("ArrowKeys", {
+InputModeTypes.ArrowKeys = InputModeType.new("ArrowKeys", {
 	Enum.KeyCode.Left;
 	Enum.KeyCode.Right;
 	Enum.KeyCode.Up;
@@ -197,11 +188,11 @@ INPUT_MODES.ArrowKeys = InputMode.new("ArrowKeys", {
 
 --[=[
 	Input involving WASD
-	@prop WASD InputMode
+	@prop WASD InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.WASD = InputMode.new("WASD", {
+InputModeTypes.WASD = InputModeType.new("WASD", {
 	Enum.KeyCode.W;
 	Enum.KeyCode.A;
 	Enum.KeyCode.S;
@@ -210,11 +201,11 @@ INPUT_MODES.WASD = InputMode.new("WASD", {
 
 --[=[
 	Input involving the mouse
-	@prop Mouse InputMode
+	@prop Mouse InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Mouse = InputMode.new("Mouse", {
+InputModeTypes.Mouse = InputModeType.new("Mouse", {
 	Enum.UserInputType.MouseButton1;
 	Enum.UserInputType.MouseButton2;
 	Enum.UserInputType.MouseButton3;
@@ -224,31 +215,31 @@ INPUT_MODES.Mouse = InputMode.new("Mouse", {
 
 --[=[
 	Input involving the keyboard OR mouse.
-	@prop KeyboardAndMoues InputMode
+	@prop KeyboardAndMoues InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.KeyboardAndMouse = InputMode.new("KeyboardAndMouse", {
-	INPUT_MODES.Mouse;
-	INPUT_MODES.Keyboard;
+InputModeTypes.KeyboardAndMouse = InputModeType.new("KeyboardAndMouse", {
+	InputModeTypes.Mouse;
+	InputModeTypes.Keyboard;
 })
 
 --[=[
 	Input involving touch input.
-	@prop Touch InputMode
+	@prop Touch InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Touch = InputMode.new("Touch", {
+InputModeTypes.Touch = InputModeType.new("Touch", {
 	Enum.UserInputType.Touch;
 })
 
 --[=[
-	@prop DPad InputMode
+	@prop DPad InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.DPad = InputMode.new("DPad", {
+InputModeTypes.DPad = InputModeType.new("DPad", {
 	Enum.KeyCode.DPadLeft;
 	Enum.KeyCode.DPadRight;
 	Enum.KeyCode.DPadUp;
@@ -257,22 +248,22 @@ INPUT_MODES.DPad = InputMode.new("DPad", {
 
 --[=[
 	Input involved thumbsticks.
-	@prop Thumbsticks InputMode
+	@prop Thumbsticks InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Thumbsticks = InputMode.new("Thumbsticks", {
+InputModeTypes.Thumbsticks = InputModeType.new("Thumbsticks", {
 	Enum.KeyCode.Thumbstick1;
 	Enum.KeyCode.Thumbstick2;
 })
 
 --[=[
 	Input involving gamepads
-	@prop Gamepads InputMode
+	@prop Gamepads InputModeType
 	@readonly
-	@within INPUT_MODES
+	@within InputModeTypes
 ]=]
-INPUT_MODES.Gamepads = InputMode.new("Gamepads", {
+InputModeTypes.Gamepads = InputModeType.new("Gamepads", {
 	Enum.UserInputType.Gamepad1;
 	Enum.UserInputType.Gamepad2;
 	Enum.UserInputType.Gamepad3;
@@ -301,69 +292,4 @@ INPUT_MODES.Gamepads = InputMode.new("Gamepads", {
 	Enum.KeyCode.DPadDown;
 })
 
-local function triggerEnabled()
-	if UserInputService.MouseEnabled then
-		INPUT_MODES.Mouse:Enable()
-	end
-	if UserInputService.TouchEnabled then
-		INPUT_MODES.Touch:Enable()
-	end
-	if UserInputService.KeyboardEnabled then
-		INPUT_MODES.Keyboard:Enable()
-	end
-	if UserInputService.KeyboardEnabled and UserInputService.MouseEnabled then
-		INPUT_MODES.KeyboardAndMouse:Enable()
-	end
-	if UserInputService.GamepadEnabled
-		or #UserInputService:GetConnectedGamepads() > 0
-		or GuiService:IsTenFootInterface() then
-		INPUT_MODES.Gamepads:Enable()
-	end
-end
-
-local function bindProcessor()
-	local inputProcessor = InputModeProcessor.new({
-		INPUT_MODES.Keypad;
-		INPUT_MODES.Keyboard;
-		INPUT_MODES.Gamepads;
-		INPUT_MODES.Mouse;
-		INPUT_MODES.Touch;
-		INPUT_MODES.ArrowKeys;
-		INPUT_MODES.WASD;
-		INPUT_MODES.KeyboardAndMouse;
-		INPUT_MODES.DPad;
-		-- Don't add INPUT_MODES.Thumbsticks, we handle it seperately
-	})
-
-	UserInputService.InputBegan:Connect(function(inputObject)
-		inputProcessor:Evaluate(inputObject)
-	end)
-	UserInputService.InputEnded:Connect(function(inputObject)
-		inputProcessor:Evaluate(inputObject)
-	end)
-	UserInputService.InputChanged:Connect(function(inputObject)
-		if inputObject.KeyCode == Enum.KeyCode.Thumbstick1
-			or inputObject.KeyCode == Enum.KeyCode.Thumbstick2 then
-
-			if inputObject.Position.magnitude > INPUT_MODES.THUMBSTICK_DEADZONE then
-				inputProcessor:Evaluate(inputObject)
-				INPUT_MODES.Thumbsticks:Enable()
-			end
-		else
-			inputProcessor:Evaluate(inputObject)
-		end
-	end)
-
-	UserInputService.GamepadConnected:Connect(function(_)
-		INPUT_MODES.Gamepads:Enable()
-	end)
-
-	UserInputService.GamepadDisconnected:Connect(function(_)
-		triggerEnabled()
-	end)
-end
-
-bindProcessor()
-triggerEnabled()
-
-return Table.readonly(INPUT_MODES)
+return Table.readonly(InputModeTypes)

package/src/Client/InputModeSelector.lua

@@ -1,229 +0,0 @@
---[=[
-	Selects the most recent input mode and attempts to identify the best state from it.
-	@class InputModeSelector
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local INPUT_MODES = require("INPUT_MODES")
-local Maid = require("Maid")
-local ValueObject = require("ValueObject")
-
-local InputModeSelector = {}
-InputModeSelector.ClassName = "InputModeSelector"
-InputModeSelector.DEFAULT_MODES = {
-	INPUT_MODES.Gamepads,
-	INPUT_MODES.Keyboard,
-	INPUT_MODES.Touch
-}
-
---[=[
-	Constructs a new InputModeSelector
-	@param inputModes { InputMode }
-	@return InputModeSelector
-]=]
-function InputModeSelector.new(inputModes)
-	local self = setmetatable({}, InputModeSelector)
-
-	self._maid = Maid.new()
-
-	-- keep this ordered so we are always stable in selection.
-	self._inputModeList = {}
-
-	self._activeMode = ValueObject.new()
-	self._maid:GiveTask(self._activeMode)
-
---[=[
-	Event that fires whenever the active mode changes.
-	@prop Changed Signal<InputMode, InputMode> -- newMode, oldMode
-	@within InputModeSelector
-]=]
-	self.Changed = self._activeMode.Changed
-
-	for _, inputMode in pairs(inputModes or InputModeSelector.DEFAULT_MODES) do
-		self:AddInputMode(inputMode)
-	end
-
-	return self
-end
-
---[=[
-	Constructs a new InputModeSelector
-	@param observeInputModesBrio Observable<Brio<InputMode>>
-	@return InputModeSelector
-]=]
-function InputModeSelector.fromObservableBrio(observeInputModesBrio)
-	local selector = InputModeSelector.new({})
-
-	selector._maid:GiveTask(observeInputModesBrio:Subscribe(function(brio)
-		if brio:IsDead() then
-			return
-		end
-
-		local inputMode = brio:GetValue()
-		local maid = brio:ToMaid()
-		selector:AddInputMode(inputMode)
-
-		maid:GiveTask(function()
-			if selector.Destroy then
-				selector:RemoveInputMode(inputMode)
-			end
-		end)
-	end))
-
-	return selector
-end
-
---[=[
-	Returns the current active mode
-	@return InputMode
-]=]
-function InputModeSelector:GetActiveMode()
-	return rawget(self, "_activeMode").Value
-end
-
---[=[
-	Observes the current active mode
-	@return Observable<InputMode>
-]=]
-function InputModeSelector:ObserveActiveMode()
-	return rawget(self, "_activeMode"):Observe()
-end
-
---[=[
-	The current active input mode
-	@prop Value InputMode?
-	@within InputModeSelector
-]=]
-function InputModeSelector:__index(index)
-	if index == "Value" then
-		return rawget(self, "_activeMode").Value
-	elseif InputModeSelector[index] then
-		return InputModeSelector[index]
-	else
-		local value = rawget(self, index)
-		if value then
-			return value
-		else
-			error(("[InputModeSelector] - Bad index '%s'"):format(tostring(index)))
-		end
-	end
-end
-
---[=[
-	Binds the updateBindFunction to the mode selector
-
-	```lua
-	local inputModeSelector = InputModeSelector.new({
-		INPUT_MODES.Mouse;
-		INPUT_MODES.Touch;
-	})
-
-	inputModeSelector:Bind(function(inputMode)
-		if inputMode == INPUT_MODES.Mouse then
-			print("Show mouse input hints")
-		elseif inputMode == INPUT_MODES.Touch then
-			print("Show touch input hints")
-		else
-			-- Unknown input mode
-			warn("Unknown input mode") -- should not occur
-		end
-	end)
-	```
-
-	@param updateBindFunction (newMode: InputMode, modeMaid: Maid) -> ()
-	@return InputModeSelector
-]=]
-function InputModeSelector:Bind(updateBindFunction)
-	local maid = Maid.new()
-	self._maid[updateBindFunction] = maid
-
-	local function onChange(newMode, _)
-		maid._modeMaid = nil
-
-		if newMode then
-			local modeMaid = Maid.new()
-			maid._modeMaid = modeMaid
-
-			if newMode then
-				updateBindFunction(newMode, modeMaid)
-			end
-		end
-	end
-
-	maid:GiveTask(self._activeMode.Changed:Connect(onChange))
-	onChange(self._activeMode.Value, nil)
-
-	return self
-end
-
---[=[
-	Removes the input mode
-	@param inputMode InputMode
-]=]
-function InputModeSelector:RemoveInputMode(inputMode)
-	if not self._maid[inputMode] then
-		return
-	end
-
-	local index = table.find(self._inputModeList, inputMode)
-	if index then
-		table.remove(self._inputModeList, index)
-	else
-		warn("[InputModeSelector] - Failed to find inputMode")
-	end
-
-	self._maid[inputMode] = nil
-
-	if self._activeMode.Value == inputMode then
-		self:_pickNewInputMode()
-	end
-end
-
---[=[
-	Adds a new input mode
-	@param inputMode InputMode
-]=]
-function InputModeSelector:AddInputMode(inputMode)
-	if self._maid[inputMode] then
-		return
-	end
-
-	table.insert(self._inputModeList, inputMode)
-	self._maid[inputMode] = inputMode.Enabled:Connect(function()
-		self._activeMode.Value = inputMode
-	end)
-
-	if not self._activeMode.Value
-		or inputMode:GetLastEnabledTime() > self._activeMode.Value:GetLastEnabledTime() then
-		self._activeMode.Value = inputMode
-	end
-end
-
-function InputModeSelector:_pickNewInputMode()
-	local bestEnabledTime = -math.huge
-	local bestMode
-	for _, inputMode in pairs(self._inputModeList) do
-		local enableTime = inputMode:GetLastEnabledTime()
-		if enableTime >= bestEnabledTime then
-			bestEnabledTime = enableTime
-			bestMode = inputMode
-		end
-	end
-
-	self._activeMode.Value = bestMode
-end
-
---[=[
-	Cleans up the input mode selector.
-
-	:::info
-	This should be called whenever the mode selector is done being used.
-	:::
-]=]
-function InputModeSelector:Destroy()
-	self._maid:DoCleaning()
-	setmetatable(self, nil)
-end
-
-return InputModeSelector