@quenty/inputmode 13.18.0 → 13.18.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [13.18.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputmode@13.18.0...@quenty/inputmode@13.18.1) (2025-04-05)
+
+
+### Bug Fixes
+
+* Add types to packages ([2374fb2](https://github.com/Quenty/NevermoreEngine/commit/2374fb2b043cfbe0e9b507b3316eec46a4e353a0))
+
+
+
+
+
 # [13.18.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputmode@13.17.2...@quenty/inputmode@13.18.0) (2025-04-02)
 
 **Note:** Version bump only for package @quenty/inputmode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/inputmode",
-  "version": "13.18.0",
+  "version": "13.18.1",
   "description": "Trace input mode state and trigger changes correctly",
   "keywords": [
     "Roblox",
@@ -25,17 +25,17 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/ducktype": "^5.8.1",
-    "@quenty/loader": "^10.8.0",
-    "@quenty/maid": "^3.4.0",
-    "@quenty/rx": "^13.17.0",
-    "@quenty/servicebag": "^11.11.1",
-    "@quenty/signal": "^7.10.0",
-    "@quenty/table": "^3.7.1",
-    "@quenty/valueobject": "^13.17.0"
+    "@quenty/ducktype": "^5.8.2",
+    "@quenty/loader": "^10.8.1",
+    "@quenty/maid": "^3.4.1",
+    "@quenty/rx": "^13.17.1",
+    "@quenty/servicebag": "^11.11.2",
+    "@quenty/signal": "^7.10.1",
+    "@quenty/table": "^3.7.2",
+    "@quenty/valueobject": "^13.17.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e8ea56930e65322fcffc05a1556d5df988068f0b"
+  "gitHead": "78c3ac0ab08dd18085b6e6e6e4f745e76ed99f68"
 }

package/src/Client/InputMode.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Trace input mode state and trigger changes correctly. See [InputModeSelector] for details
 	on how to select between these. See [InputModeTypeTypes] for predefined modes.
@@ -9,6 +10,7 @@ local require = require(script.Parent.loader).load(script)
 
 local Signal = require("Signal")
 local DuckTypeUtils = require("DuckTypeUtils")
+local _InputModeType = require("InputModeType")
 
 --[=[
 	Fires off when the mode is enabled
@@ -26,13 +28,22 @@ local InputMode = {}
 InputMode.__index = InputMode
 InputMode.ClassName = "InputMode"
 
+export type InputMode = typeof(setmetatable(
+	{} :: {
+		_inputModeType: _InputModeType.InputModeType,
+		_lastEnabled: number,
+		Enabled: Signal.Signal<()>,
+	},
+	InputMode
+))
+
 --[=[
 	Constructs a new InputMode. This inherits data from the name.
 
 	@param inputModeType InputModeType
 	@return InputMode
 ]=]
-function InputMode.new(inputModeType)
+function InputMode.new(inputModeType: _InputModeType.InputModeType): InputMode
 	local self = setmetatable({}, InputMode)
 
 	self._inputModeType = assert(inputModeType, "Bad inputModeType")
@@ -50,7 +61,7 @@ end
 	@param value any
 	@return boolean
 ]=]
-function InputMode.isInputMode(value)
+function InputMode.isInputMode(value: any): boolean
 	return DuckTypeUtils.isImplementation(InputMode, value)
 end
 
@@ -58,7 +69,7 @@ end
 	Checks the last point this input mode was used.
 	@return number
 ]=]
-function InputMode:GetLastEnabledTime()
+function InputMode.GetLastEnabledTime(self: InputMode): number
 	return self._lastEnabled
 end
 
@@ -66,7 +77,7 @@ end
 	Returns all keys defining the input mode.
 	@return { UserInputType | KeyCode | string }
 ]=]
-function InputMode:GetKeys()
+function InputMode.GetKeys(self: InputMode): { Enum.UserInputType | Enum.KeyCode | string }
 	return self._inputModeType:GetKeys()
 end
 
@@ -75,7 +86,7 @@ end
 	@param inputType { UserInputType | KeyCode | string }
 	@return boolean
 ]=]
-function InputMode:IsValid(inputType)
+function InputMode.IsValid(self: InputMode, inputType: _InputModeType.InputModeKey): boolean
 	assert(inputType, "Must send in inputType")
 
 	return self._inputModeType:IsValid(inputType)
@@ -84,7 +95,7 @@ end
 --[=[
 	Enables the mode
 ]=]
-function InputMode:Enable()
+function InputMode.Enable(self: InputMode)
 	self._lastEnabled = os.clock()
 	self.Enabled:Fire()
 end
@@ -93,10 +104,8 @@ end
 	Evaluates the input object, and if it's valid, enables the mode
 	@param inputObject InputObject
 ]=]
-function InputMode:Evaluate(inputObject)
-	if self._inputModeType:IsValid(inputObject.UserInputType)
-		or self._inputModeType:IsValid(inputObject.KeyCode) then
-
+function InputMode.Evaluate(self: InputMode, inputObject: InputObject)
+	if self._inputModeType:IsValid(inputObject.UserInputType) or self._inputModeType:IsValid(inputObject.KeyCode) then
 		self:Enable()
 	end
 end
@@ -104,7 +113,7 @@ end
 --[=[
 	Cleans up the input mode
 ]=]
-function InputMode:Destroy()
+function InputMode.Destroy(self: InputMode)
 	self.Enabled:Destroy()
 end
 

package/src/Client/InputModeProcessor.lua

@@ -4,22 +4,33 @@
 	@class InputModeProcessor
 ]=]
 
+local require = require(script.Parent.loader).load(script)
+
+local _InputMode = require("InputMode")
+
 local InputModeProcessor = {}
 InputModeProcessor.__index = InputModeProcessor
 InputModeProcessor.ClassName = InputModeProcessor
 
+export type InputModeProcessor = typeof(setmetatable(
+	{} :: {
+		_inputModes: { _InputMode.InputMode },
+	},
+	InputModeProcessor
+))
+
 --[=[
 	Construtcs a new inputModeProcessor
 	@param inputModes { InputMode }?
 	@return InputModeProcessor
 ]=]
-function InputModeProcessor.new(inputModes)
+function InputModeProcessor.new(inputModes: { _InputMode.InputMode }?): InputModeProcessor
 	local self = setmetatable({}, InputModeProcessor)
 
 	self._inputModes = {}
 
 	if inputModes then
-		for _, inputMode in pairs(inputModes) do
+		for _, inputMode in inputModes do
 			self:AddInputMode(inputMode)
 		end
 	end
@@ -27,7 +38,11 @@ function InputModeProcessor.new(inputModes)
 	return self
 end
 
-function InputModeProcessor:AddInputMode(inputMode)
+--[=[
+	Adds an input mode to the inputModeProcessor
+	@param inputMode InputMode
+]=]
+function InputModeProcessor.AddInputMode(self: InputModeProcessor, inputMode: _InputMode.InputMode)
 	table.insert(self._inputModes, inputMode)
 end
 
@@ -35,7 +50,7 @@ end
 	Gets all input mode inputModes being used
 	@return { InputMode }
 ]=]
-function InputModeProcessor:GetStates()
+function InputModeProcessor.GetStates(self: InputModeProcessor): { _InputMode.InputMode }
 	return self._inputModes
 end
 
@@ -43,8 +58,8 @@ end
 	Applies the inputObject as an evaluation for the inputm odes
 	@param inputObject InputObject
 ]=]
-function InputModeProcessor:Evaluate(inputObject)
-	for _, inputMode in pairs(self._inputModes) do
+function InputModeProcessor.Evaluate(self: InputModeProcessor, inputObject: InputObject)
+	for _, inputMode in self._inputModes do
 		inputMode:Evaluate(inputObject)
 	end
 end

package/src/Client/InputModeServiceClient.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Centralized
 	@class InputModeServiceClient
@@ -14,13 +15,25 @@ local Maid = require("Maid")
 local InputModeProcessor = require("InputModeProcessor")
 local InputModeTypes = require("InputModeTypes")
 local InputMode = require("InputMode")
+local _ServiceBag = require("ServiceBag")
 
 local THUMBSTICK_DEADZONE = 0.14
 
 local InputModeServiceClient = {}
 InputModeServiceClient.ServiceName = "InputModeServiceClient"
 
-function InputModeServiceClient:Init(serviceBag)
+export type InputModeServiceClient = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_inputModes: { [InputModeType.InputModeType]: InputMode.InputMode },
+		_inputModeProcessor: InputModeProcessor.InputModeProcessor,
+		_lastMousePosition: Vector3?,
+		_serviceBag: _ServiceBag.ServiceBag,
+	},
+	{ __index = InputModeServiceClient }
+))
+
+function InputModeServiceClient.Init(self: InputModeServiceClient, serviceBag: _ServiceBag.ServiceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
 
@@ -31,22 +44,25 @@ function InputModeServiceClient:Init(serviceBag)
 
 	-- 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);
+	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)
+function InputModeServiceClient.GetInputMode(
+	self: InputModeServiceClient,
+	inputModeType: InputModeType.InputModeType
+): InputMode.InputMode
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
 	if not RunService:IsRunning() then
@@ -80,7 +96,7 @@ function InputModeServiceClient:GetInputMode(inputModeType)
 	return inputMode
 end
 
-function InputModeServiceClient:_triggerEnabled()
+function InputModeServiceClient._triggerEnabled(self: InputModeServiceClient)
 	if UserInputService.MouseEnabled then
 		self:GetInputMode(InputModeTypes.Mouse):Enable()
 	end
@@ -93,25 +109,25 @@ function InputModeServiceClient:_triggerEnabled()
 	if UserInputService.KeyboardEnabled and UserInputService.MouseEnabled then
 		self:GetInputMode(InputModeTypes.KeyboardAndMouse):Enable()
 	end
-	if UserInputService.GamepadEnabled
+	if
+		UserInputService.GamepadEnabled
 		or #UserInputService:GetConnectedGamepads() > 0
-		or GuiService:IsTenFootInterface() then
+		or GuiService:IsTenFootInterface()
+	then
 		self:GetInputMode(InputModeTypes.Gamepads):Enable()
 	end
 end
 
-function InputModeServiceClient:_bindProcessor()
-	self._maid:GiveTask(UserInputService.InputBegan:Connect(function(inputObject)
+function InputModeServiceClient._bindProcessor(self: InputModeServiceClient)
+	self._maid:GiveTask(UserInputService.InputBegan:Connect(function(inputObject: InputObject)
 		self._inputModeProcessor:Evaluate(inputObject)
 	end))
-	self._maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject)
+	self._maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject: 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._maid:GiveTask(UserInputService.InputChanged:Connect(function(inputObject: 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
@@ -134,13 +150,16 @@ function InputModeServiceClient:_bindProcessor()
 	end))
 end
 
-function InputModeServiceClient:_shouldProcessMouseMovement(inputObject)
+function InputModeServiceClient._shouldProcessMouseMovement(
+	self: InputModeServiceClient,
+	inputObject: InputObject
+): boolean
 	-- Prevent mouse movement from flickering
 	local position = inputObject.Position
-	local lastMousePosition = self._lastMousePosition
+	local lastMousePosition: Vector3? = self._lastMousePosition
 	self._lastMousePosition = position
 
-	if inputObject.Delta.magnitude > 0 then
+	if inputObject.Delta.Magnitude > 0 then
 		return true
 	end
 
@@ -148,14 +167,14 @@ function InputModeServiceClient:_shouldProcessMouseMovement(inputObject)
 		return true
 	end
 
-	if (lastMousePosition - position).magnitude > 0 then
+	if (lastMousePosition - position).Magnitude > 0 then
 		return true
 	end
 
 	return false
 end
 
-function InputModeServiceClient:Destroy()
+function InputModeServiceClient.Destroy(self: InputModeServiceClient)
 	self._maid:DoCleaning()
 end
 

package/src/Client/InputModeTypeSelector.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Selects the most recent input mode and attempts to identify the best state from it.
 	@class InputModeTypeSelector
@@ -12,14 +13,31 @@ local InputModeServiceClient = require("InputModeServiceClient")
 local ServiceBag = require("ServiceBag")
 local Rx = require("Rx")
 local InputModeType = require("InputModeType")
+local _Observable = require("Observable")
+local _Signal = require("Signal")
+local _Brio = require("Brio")
 
 local InputModeTypeSelector = {}
 InputModeTypeSelector.ClassName = "InputModeTypeSelector"
 InputModeTypeSelector.DEFAULT_MODE_TYPES = {
 	InputModeTypes.Gamepads,
 	InputModeTypes.Keyboard,
-	InputModeTypes.Touch
-}
+	InputModeTypes.Touch,
+} :: { InputModeType.InputModeType }
+
+export type InputModeTypeSelector = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_inputModeTypeList: { InputModeType.InputModeType },
+		_activeModeType: ValueObject.ValueObject<InputModeType.InputModeType>,
+		_serviceBag: ServiceBag.ServiceBag,
+		_inputModeServiceClient: InputModeServiceClient.InputModeServiceClient,
+
+		Value: InputModeType.InputModeType?,
+		Changed: _Signal.Signal<InputModeType.InputModeType, InputModeType.InputModeType>,
+	},
+	{ __index = InputModeTypeSelector }
+))
 
 --[=[
 	Constructs a new InputModeTypeSelector
@@ -28,8 +46,11 @@ InputModeTypeSelector.DEFAULT_MODE_TYPES = {
 	@param inputModesTypes { InputModeType }
 	@return InputModeTypeSelector
 ]=]
-function InputModeTypeSelector.new(serviceBag, inputModesTypes)
-	local self = setmetatable({}, InputModeTypeSelector)
+function InputModeTypeSelector.new(
+	serviceBag: ServiceBag.ServiceBag,
+	inputModesTypes: { InputModeType.InputModeType }
+): InputModeTypeSelector
+	local self: any = setmetatable({}, InputModeTypeSelector)
 
 	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
 
@@ -44,14 +65,14 @@ function InputModeTypeSelector.new(serviceBag, inputModesTypes)
 
 	self._activeModeType = self._maid:Add(ValueObject.new())
 
---[=[
+	--[=[
 	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
+	for _, inputModeType in inputModesTypes or InputModeTypeSelector.DEFAULT_MODE_TYPES do
 		self:AddInputModeType(inputModeType)
 	end
 
@@ -65,7 +86,10 @@ end
 	@param observeInputModesBrio Observable<Brio<InputModeType>>
 	@return InputModeTypeSelector
 ]=]
-function InputModeTypeSelector.fromObservableBrio(serviceBag, observeInputModesBrio)
+function InputModeTypeSelector.fromObservableBrio(
+	serviceBag: ServiceBag.ServiceBag,
+	observeInputModesBrio: _Observable.Observable<_Brio.Brio<InputModeType.InputModeType>>
+): InputModeTypeSelector
 	local selector = InputModeTypeSelector.new(serviceBag, {})
 
 	selector._maid:GiveTask(observeInputModesBrio:Subscribe(function(brio)
@@ -91,16 +115,16 @@ end
 	Returns the current active mode
 	@return InputModeType
 ]=]
-function InputModeTypeSelector:GetActiveInputType()
-	return rawget(self, "_activeModeType").Value
+function InputModeTypeSelector.GetActiveInputType(self: InputModeTypeSelector)
+	return rawget(self :: any, "_activeModeType").Value
 end
 
 --[=[
 	Observes the current active mode
 	@return Observable<InputModeType>
 ]=]
-function InputModeTypeSelector:ObserveActiveInputType()
-	return rawget(self, "_activeModeType"):Observe()
+function InputModeTypeSelector.ObserveActiveInputType(self: InputModeTypeSelector)
+	return rawget(self :: any, "_activeModeType"):Observe()
 end
 
 --[=[
@@ -109,10 +133,10 @@ end
 	@param inputModeType InputModeType
 	@return boolean
 ]=]
-function InputModeTypeSelector:IsActive(inputModeType)
+function InputModeTypeSelector.IsActive(self: InputModeTypeSelector, inputModeType: InputModeType.InputModeType)
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
-	return rawget(self, "_activeModeType").Value == inputModeType
+	return rawget(self :: any, "_activeModeType").Value == inputModeType
 end
 
 --[=[
@@ -121,14 +145,17 @@ end
 	@param inputModeType InputModeType
 	@return Observable<boolean>
 ]=]
-function InputModeTypeSelector:ObserveIsActive(inputModeType)
+function InputModeTypeSelector.ObserveIsActive(
+	self: InputModeTypeSelector,
+	inputModeType: InputModeType.InputModeType
+): _Observable.Observable<boolean>
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
 	return self:ObserveActiveInputType():Pipe({
-		Rx.map(function(inputType)
+		Rx.map(function(inputType: InputModeType.InputModeType)
 			return inputType == inputModeType
-		end);
-		Rx.distinct();
+		end) :: any,
+		Rx.distinct(),
 	})
 end
 
@@ -137,13 +164,13 @@ end
 	@prop Value InputModeType?
 	@within InputModeTypeSelector
 ]=]
-function InputModeTypeSelector:__index(index)
+function InputModeTypeSelector.__index(self: InputModeTypeSelector, index)
 	if index == "Value" then
-		return rawget(self, "_activeModeType").Value
+		return rawget(self :: any, "_activeModeType").Value
 	elseif InputModeTypeSelector[index] then
 		return InputModeTypeSelector[index]
 	else
-		local value = rawget(self, index)
+		local value = rawget(self :: any, index)
 		if value then
 			return value
 		else
@@ -176,9 +203,12 @@ end
 	@param updateBindFunction (newMode: InputModeType, modeMaid: Maid) -> ()
 	@return InputModeTypeSelector
 ]=]
-function InputModeTypeSelector:Bind(updateBindFunction)
+function InputModeTypeSelector.Bind(
+	self: InputModeTypeSelector,
+	updateBindFunction: (InputModeType.InputModeType, Maid.Maid) -> ()
+): InputModeTypeSelector
 	local maid = Maid.new()
-	self._maid[updateBindFunction] = maid
+	self._maid[updateBindFunction :: any] = maid
 
 	local function onChange(newMode, _)
 		maid._modeMaid = nil
@@ -203,10 +233,13 @@ end
 	Removes the input mode
 	@param inputModeType InputModeType
 ]=]
-function InputModeTypeSelector:RemoveInputModeType(inputModeType)
+function InputModeTypeSelector.RemoveInputModeType(
+	self: InputModeTypeSelector,
+	inputModeType: InputModeType.InputModeType
+)
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
-	if not self._maid[inputModeType] then
+	if not self._maid[inputModeType :: any] then
 		return
 	end
 
@@ -217,7 +250,7 @@ function InputModeTypeSelector:RemoveInputModeType(inputModeType)
 		warn("[InputModeTypeSelector] - Failed to find inputModeType")
 	end
 
-	self._maid[inputModeType] = nil
+	self._maid[inputModeType :: any] = nil
 
 	if self._activeModeType.Value == inputModeType then
 		self:_pickNewInputMode()
@@ -228,29 +261,32 @@ end
 	Adds a new input mode
 	@param inputModeType InputModeType
 ]=]
-function InputModeTypeSelector:AddInputModeType(inputModeType)
+function InputModeTypeSelector.AddInputModeType(self: InputModeTypeSelector, inputModeType: InputModeType.InputModeType)
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
-	if self._maid[inputModeType] then
+	if self._maid[inputModeType :: any] then
 		return
 	end
 
 	table.insert(self._inputModeTypeList, inputModeType)
 	local inputMode = self._inputModeServiceClient:GetInputMode(inputModeType)
-	self._maid[inputModeType] = inputMode.Enabled:Connect(function()
+	self._maid[inputModeType :: any] = 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
+	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()
+function InputModeTypeSelector._pickNewInputMode(self: InputModeTypeSelector)
 	local bestEnabledTime = -math.huge
 	local bestModeType
-	for _, inputModeType in pairs(self._inputModeTypeList) do
+	for _, inputModeType in self._inputModeTypeList do
 		local enableTime = self._inputModeServiceClient:GetInputMode(inputModeType):GetLastEnabledTime()
 		if enableTime >= bestEnabledTime then
 			bestEnabledTime = enableTime
@@ -268,9 +304,9 @@ end
 	This should be called whenever the mode selector is done being used.
 	:::
 ]=]
-function InputModeTypeSelector:Destroy()
+function InputModeTypeSelector.Destroy(self: InputModeTypeSelector)
 	self._maid:DoCleaning()
-	setmetatable(self, nil)
+	setmetatable(self :: any, nil)
 end
 
 return InputModeTypeSelector

package/src/Shared/InputModeType.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Type specification for input modes, which is static. Separated out from InputMode which is dynamic.
 
@@ -12,21 +13,33 @@ local InputModeType = {}
 InputModeType.ClassName = "InputModeType"
 InputModeType.__index = InputModeType
 
+export type InputModeType = typeof(setmetatable(
+	{} :: {
+		_keys: { any },
+		_valid: { [any]: boolean },
+		Name: string,
+	},
+	InputModeType
+))
+
+export type InputModeKey = Enum.UserInputType | Enum.KeyCode | string
+export type InputModeTypeDefinition = { InputModeType | InputModeKey }
+
 --[=[
 	Constructs a new InputModeType
 
 	@param name string
-	@param typesAndInputModes { { UserInputType | KeyCode | string | InputMode } }
+	@param typesAndInputModeTypes { Enum.UserInputType | Enum.KeyCode | string | InputModeType }
 	@return InputMode
 ]=]
-function InputModeType.new(name, typesAndInputModes)
+function InputModeType.new(name: string, typesAndInputModeTypes: InputModeTypeDefinition)
 	local self = setmetatable({}, InputModeType)
 
 	self._valid = {}
 	self._keys = {}
 	self.Name = name or "Unnamed"
 
-	self:_addValidTypesFromTable(typesAndInputModes)
+	self:_addValidTypesFromTable(typesAndInputModeTypes)
 
 	return self
 end
@@ -36,7 +49,7 @@ end
 	@param value any
 	@return boolean
 ]=]
-function InputModeType.isInputModeType(value)
+function InputModeType.isInputModeType(value: any): boolean
 	return DuckTypeUtils.isImplementation(InputModeType, value)
 end
 
@@ -45,7 +58,7 @@ end
 	@param inputType { UserInputType | KeyCode | string }
 	@return boolean
 ]=]
-function InputModeType:IsValid(inputType)
+function InputModeType.IsValid(self: InputModeType, inputType: InputModeKey): boolean
 	assert(inputType, "Must send in inputType")
 
 	return self._valid[inputType]
@@ -55,29 +68,29 @@ end
 	Returns all keys defining the input mode.
 	@return { UserInputType | KeyCode | string }
 ]=]
-function InputModeType:GetKeys()
+function InputModeType.GetKeys(self: InputModeType): { InputModeKey }
 	return self._keys
 end
 
-function InputModeType:_addValidTypesFromTable(keys)
-	for _, key in pairs(keys) do
+function InputModeType._addValidTypesFromTable(self: InputModeType, keys: { InputModeKey | InputModeType })
+	for _, key in keys do
 		if typeof(key) == "EnumItem" then
 			if not self._valid[key] then
 				self._valid[key] = true
 				table.insert(self._keys, key)
 			end
 		elseif InputModeType.isInputModeType(key) then
-			self:_addInputModeType(key)
+			self:_addInputModeType(key :: any)
 		else
 			warn(string.format("[InputModeType] - Invalid key of value %q of type %s", tostring(key), typeof(key)))
 		end
 	end
 end
 
-function InputModeType:_addInputModeType(inputModeType)
+function InputModeType._addInputModeType(self: InputModeType, inputModeType: InputModeType)
 	assert(InputModeType.isInputModeType(inputModeType), "Bad inputModeType")
 
-	for _, key in pairs(inputModeType._keys) do
+	for _, key in inputModeType._keys do
 		if not self._valid[key] then
 			self._valid[key] = true
 			table.insert(self._keys, key)
@@ -85,6 +98,4 @@ function InputModeType:_addInputModeType(inputModeType)
 	end
 end
 
-
-
 return InputModeType

package/src/Shared/InputModeTypes.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Holds all the input mode type configuration, accessible on both the server and the client for keybinding validations.
 	@class InputModeTypes
@@ -17,23 +18,23 @@ local InputModeTypes = {}
 	@within InputModeTypes
 ]=]
 InputModeTypes.Keypad = InputModeType.new("Keypad", {
-	Enum.KeyCode.KeypadZero;
-	Enum.KeyCode.KeypadOne;
-	Enum.KeyCode.KeypadTwo;
-	Enum.KeyCode.KeypadThree;
-	Enum.KeyCode.KeypadFour;
-	Enum.KeyCode.KeypadFive;
-	Enum.KeyCode.KeypadSix;
-	Enum.KeyCode.KeypadSeven;
-	Enum.KeyCode.KeypadEight;
-	Enum.KeyCode.KeypadNine;
-	Enum.KeyCode.KeypadPeriod;
-	Enum.KeyCode.KeypadDivide;
-	Enum.KeyCode.KeypadMultiply;
-	Enum.KeyCode.KeypadMinus;
-	Enum.KeyCode.KeypadPlus;
-	Enum.KeyCode.KeypadEnter;
-	Enum.KeyCode.KeypadEquals;
+	Enum.KeyCode.KeypadZero,
+	Enum.KeyCode.KeypadOne,
+	Enum.KeyCode.KeypadTwo,
+	Enum.KeyCode.KeypadThree,
+	Enum.KeyCode.KeypadFour,
+	Enum.KeyCode.KeypadFive,
+	Enum.KeyCode.KeypadSix,
+	Enum.KeyCode.KeypadSeven,
+	Enum.KeyCode.KeypadEight,
+	Enum.KeyCode.KeypadNine,
+	Enum.KeyCode.KeypadPeriod,
+	Enum.KeyCode.KeypadDivide,
+	Enum.KeyCode.KeypadMultiply,
+	Enum.KeyCode.KeypadMinus,
+	Enum.KeyCode.KeypadPlus,
+	Enum.KeyCode.KeypadEnter,
+	Enum.KeyCode.KeypadEquals,
 })
 
 --[=[
@@ -43,134 +44,134 @@ InputModeTypes.Keypad = InputModeType.new("Keypad", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.Keyboard = InputModeType.new("Keyboard", {
-	Enum.UserInputType.Keyboard;
+	Enum.UserInputType.Keyboard,
 
 	-- Other input modes
-	InputModeTypes.Keypad;
+	InputModeTypes.Keypad,
 
 	-- Valid KeyCodes for input binding
-	Enum.KeyCode.Backspace;
-	Enum.KeyCode.Tab;
-	Enum.KeyCode.Clear;
-	Enum.KeyCode.Return;
-	Enum.KeyCode.Pause;
-	Enum.KeyCode.Escape;
-	Enum.KeyCode.Space;
-	Enum.KeyCode.QuotedDouble;
-	Enum.KeyCode.Hash;
-	Enum.KeyCode.Dollar;
-	Enum.KeyCode.Percent;
-	Enum.KeyCode.Ampersand;
-	Enum.KeyCode.Quote;
-	Enum.KeyCode.LeftParenthesis;
-	Enum.KeyCode.RightParenthesis;
-	Enum.KeyCode.Asterisk;
-	Enum.KeyCode.Plus;
-	Enum.KeyCode.Comma;
-	Enum.KeyCode.Minus;
-	Enum.KeyCode.Period;
-	Enum.KeyCode.Slash;
-	Enum.KeyCode.Zero;
-	Enum.KeyCode.One;
-	Enum.KeyCode.Two;
-	Enum.KeyCode.Three;
-	Enum.KeyCode.Four;
-	Enum.KeyCode.Five;
-	Enum.KeyCode.Six;
-	Enum.KeyCode.Seven;
-	Enum.KeyCode.Eight;
-	Enum.KeyCode.Nine;
-	Enum.KeyCode.Colon;
-	Enum.KeyCode.Semicolon;
-	Enum.KeyCode.LessThan;
-	Enum.KeyCode.Equals;
-	Enum.KeyCode.GreaterThan;
-	Enum.KeyCode.Question;
-	Enum.KeyCode.At;
-	Enum.KeyCode.LeftBracket;
-	Enum.KeyCode.BackSlash;
-	Enum.KeyCode.RightBracket;
-	Enum.KeyCode.Caret;
-	Enum.KeyCode.Underscore;
-	Enum.KeyCode.Backquote;
-	Enum.KeyCode.A;
-	Enum.KeyCode.B;
-	Enum.KeyCode.C;
-	Enum.KeyCode.D;
-	Enum.KeyCode.E;
-	Enum.KeyCode.F;
-	Enum.KeyCode.G;
-	Enum.KeyCode.H;
-	Enum.KeyCode.I;
-	Enum.KeyCode.J;
-	Enum.KeyCode.K;
-	Enum.KeyCode.L;
-	Enum.KeyCode.M;
-	Enum.KeyCode.N;
-	Enum.KeyCode.O;
-	Enum.KeyCode.P;
-	Enum.KeyCode.Q;
-	Enum.KeyCode.R;
-	Enum.KeyCode.S;
-	Enum.KeyCode.T;
-	Enum.KeyCode.U;
-	Enum.KeyCode.V;
-	Enum.KeyCode.W;
-	Enum.KeyCode.X;
-	Enum.KeyCode.Y;
-	Enum.KeyCode.Z;
-	Enum.KeyCode.LeftCurly;
-	Enum.KeyCode.Pipe;
-	Enum.KeyCode.RightCurly;
-	Enum.KeyCode.Tilde;
-	Enum.KeyCode.Delete;
-	Enum.KeyCode.Up;
-	Enum.KeyCode.Down;
-	Enum.KeyCode.Right;
-	Enum.KeyCode.Left;
-	Enum.KeyCode.Insert;
-	Enum.KeyCode.Home;
-	Enum.KeyCode.End;
-	Enum.KeyCode.PageUp;
-	Enum.KeyCode.PageDown;
-	Enum.KeyCode.F1;
-	Enum.KeyCode.F2;
-	Enum.KeyCode.F3;
-	Enum.KeyCode.F4;
-	Enum.KeyCode.F5;
-	Enum.KeyCode.F6;
-	Enum.KeyCode.F7;
-	Enum.KeyCode.F8;
-	Enum.KeyCode.F9;
-	Enum.KeyCode.F10;
-	Enum.KeyCode.F11;
-	Enum.KeyCode.F12;
-	Enum.KeyCode.F13;
-	Enum.KeyCode.F14;
-	Enum.KeyCode.F15;
-	Enum.KeyCode.NumLock;
-	Enum.KeyCode.CapsLock;
-	Enum.KeyCode.ScrollLock;
-	Enum.KeyCode.RightShift;
-	Enum.KeyCode.LeftShift;
-	Enum.KeyCode.RightControl;
-	Enum.KeyCode.LeftControl;
-	Enum.KeyCode.RightAlt;
-	Enum.KeyCode.LeftAlt;
-	Enum.KeyCode.RightMeta;
-	Enum.KeyCode.LeftMeta;
-	Enum.KeyCode.LeftSuper;
-	Enum.KeyCode.RightSuper;
-	Enum.KeyCode.Mode;
-	Enum.KeyCode.Compose;
-	Enum.KeyCode.Help;
-	Enum.KeyCode.Print;
-	Enum.KeyCode.SysReq;
-	Enum.KeyCode.Break;
-	Enum.KeyCode.Menu;
-	Enum.KeyCode.Power;
-	Enum.KeyCode.Euro;
-	Enum.KeyCode.Undo;
+	Enum.KeyCode.Backspace,
+	Enum.KeyCode.Tab,
+	Enum.KeyCode.Clear,
+	Enum.KeyCode.Return,
+	Enum.KeyCode.Pause,
+	Enum.KeyCode.Escape,
+	Enum.KeyCode.Space,
+	Enum.KeyCode.QuotedDouble,
+	Enum.KeyCode.Hash,
+	Enum.KeyCode.Dollar,
+	Enum.KeyCode.Percent,
+	Enum.KeyCode.Ampersand,
+	Enum.KeyCode.Quote,
+	Enum.KeyCode.LeftParenthesis,
+	Enum.KeyCode.RightParenthesis,
+	Enum.KeyCode.Asterisk,
+	Enum.KeyCode.Plus,
+	Enum.KeyCode.Comma,
+	Enum.KeyCode.Minus,
+	Enum.KeyCode.Period,
+	Enum.KeyCode.Slash,
+	Enum.KeyCode.Zero,
+	Enum.KeyCode.One,
+	Enum.KeyCode.Two,
+	Enum.KeyCode.Three,
+	Enum.KeyCode.Four,
+	Enum.KeyCode.Five,
+	Enum.KeyCode.Six,
+	Enum.KeyCode.Seven,
+	Enum.KeyCode.Eight,
+	Enum.KeyCode.Nine,
+	Enum.KeyCode.Colon,
+	Enum.KeyCode.Semicolon,
+	Enum.KeyCode.LessThan,
+	Enum.KeyCode.Equals,
+	Enum.KeyCode.GreaterThan,
+	Enum.KeyCode.Question,
+	Enum.KeyCode.At,
+	Enum.KeyCode.LeftBracket,
+	Enum.KeyCode.BackSlash,
+	Enum.KeyCode.RightBracket,
+	Enum.KeyCode.Caret,
+	Enum.KeyCode.Underscore,
+	Enum.KeyCode.Backquote,
+	Enum.KeyCode.A,
+	Enum.KeyCode.B,
+	Enum.KeyCode.C,
+	Enum.KeyCode.D,
+	Enum.KeyCode.E,
+	Enum.KeyCode.F,
+	Enum.KeyCode.G,
+	Enum.KeyCode.H,
+	Enum.KeyCode.I,
+	Enum.KeyCode.J,
+	Enum.KeyCode.K,
+	Enum.KeyCode.L,
+	Enum.KeyCode.M,
+	Enum.KeyCode.N,
+	Enum.KeyCode.O,
+	Enum.KeyCode.P,
+	Enum.KeyCode.Q,
+	Enum.KeyCode.R,
+	Enum.KeyCode.S,
+	Enum.KeyCode.T,
+	Enum.KeyCode.U,
+	Enum.KeyCode.V,
+	Enum.KeyCode.W,
+	Enum.KeyCode.X,
+	Enum.KeyCode.Y,
+	Enum.KeyCode.Z,
+	Enum.KeyCode.LeftCurly,
+	Enum.KeyCode.Pipe,
+	Enum.KeyCode.RightCurly,
+	Enum.KeyCode.Tilde,
+	Enum.KeyCode.Delete,
+	Enum.KeyCode.Up,
+	Enum.KeyCode.Down,
+	Enum.KeyCode.Right,
+	Enum.KeyCode.Left,
+	Enum.KeyCode.Insert,
+	Enum.KeyCode.Home,
+	Enum.KeyCode.End,
+	Enum.KeyCode.PageUp,
+	Enum.KeyCode.PageDown,
+	Enum.KeyCode.F1,
+	Enum.KeyCode.F2,
+	Enum.KeyCode.F3,
+	Enum.KeyCode.F4,
+	Enum.KeyCode.F5,
+	Enum.KeyCode.F6,
+	Enum.KeyCode.F7,
+	Enum.KeyCode.F8,
+	Enum.KeyCode.F9,
+	Enum.KeyCode.F10,
+	Enum.KeyCode.F11,
+	Enum.KeyCode.F12,
+	Enum.KeyCode.F13,
+	Enum.KeyCode.F14,
+	Enum.KeyCode.F15,
+	Enum.KeyCode.NumLock,
+	Enum.KeyCode.CapsLock,
+	Enum.KeyCode.ScrollLock,
+	Enum.KeyCode.RightShift,
+	Enum.KeyCode.LeftShift,
+	Enum.KeyCode.RightControl,
+	Enum.KeyCode.LeftControl,
+	Enum.KeyCode.RightAlt,
+	Enum.KeyCode.LeftAlt,
+	Enum.KeyCode.RightMeta,
+	Enum.KeyCode.LeftMeta,
+	Enum.KeyCode.LeftSuper,
+	Enum.KeyCode.RightSuper,
+	Enum.KeyCode.Mode,
+	Enum.KeyCode.Compose,
+	Enum.KeyCode.Help,
+	Enum.KeyCode.Print,
+	Enum.KeyCode.SysReq,
+	Enum.KeyCode.Break,
+	Enum.KeyCode.Menu,
+	Enum.KeyCode.Power,
+	Enum.KeyCode.Euro,
+	Enum.KeyCode.Undo,
 })
 
 --[=[
@@ -180,10 +181,10 @@ InputModeTypes.Keyboard = InputModeType.new("Keyboard", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.ArrowKeys = InputModeType.new("ArrowKeys", {
-	Enum.KeyCode.Left;
-	Enum.KeyCode.Right;
-	Enum.KeyCode.Up;
-	Enum.KeyCode.Down;
+	Enum.KeyCode.Left,
+	Enum.KeyCode.Right,
+	Enum.KeyCode.Up,
+	Enum.KeyCode.Down,
 })
 
 --[=[
@@ -193,10 +194,10 @@ InputModeTypes.ArrowKeys = InputModeType.new("ArrowKeys", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.WASD = InputModeType.new("WASD", {
-	Enum.KeyCode.W;
-	Enum.KeyCode.A;
-	Enum.KeyCode.S;
-	Enum.KeyCode.D;
+	Enum.KeyCode.W,
+	Enum.KeyCode.A,
+	Enum.KeyCode.S,
+	Enum.KeyCode.D,
 })
 
 --[=[
@@ -206,11 +207,11 @@ InputModeTypes.WASD = InputModeType.new("WASD", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.Mouse = InputModeType.new("Mouse", {
-	Enum.UserInputType.MouseButton1;
-	Enum.UserInputType.MouseButton2;
-	Enum.UserInputType.MouseButton3;
-	Enum.UserInputType.MouseWheel;
-	Enum.UserInputType.MouseMovement;
+	Enum.UserInputType.MouseButton1,
+	Enum.UserInputType.MouseButton2,
+	Enum.UserInputType.MouseButton3,
+	Enum.UserInputType.MouseWheel,
+	Enum.UserInputType.MouseMovement,
 })
 
 --[=[
@@ -220,8 +221,8 @@ InputModeTypes.Mouse = InputModeType.new("Mouse", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.KeyboardAndMouse = InputModeType.new("KeyboardAndMouse", {
-	InputModeTypes.Mouse;
-	InputModeTypes.Keyboard;
+	InputModeTypes.Mouse,
+	InputModeTypes.Keyboard,
 })
 
 --[=[
@@ -231,7 +232,7 @@ InputModeTypes.KeyboardAndMouse = InputModeType.new("KeyboardAndMouse", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.Touch = InputModeType.new("Touch", {
-	Enum.UserInputType.Touch;
+	Enum.UserInputType.Touch,
 })
 
 --[=[
@@ -240,10 +241,10 @@ InputModeTypes.Touch = InputModeType.new("Touch", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.DPad = InputModeType.new("DPad", {
-	Enum.KeyCode.DPadLeft;
-	Enum.KeyCode.DPadRight;
-	Enum.KeyCode.DPadUp;
-	Enum.KeyCode.DPadDown;
+	Enum.KeyCode.DPadLeft,
+	Enum.KeyCode.DPadRight,
+	Enum.KeyCode.DPadUp,
+	Enum.KeyCode.DPadDown,
 })
 
 --[=[
@@ -253,8 +254,8 @@ InputModeTypes.DPad = InputModeType.new("DPad", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.Thumbsticks = InputModeType.new("Thumbsticks", {
-	Enum.KeyCode.Thumbstick1;
-	Enum.KeyCode.Thumbstick2;
+	Enum.KeyCode.Thumbstick1,
+	Enum.KeyCode.Thumbstick2,
 })
 
 --[=[
@@ -264,32 +265,45 @@ InputModeTypes.Thumbsticks = InputModeType.new("Thumbsticks", {
 	@within InputModeTypes
 ]=]
 InputModeTypes.Gamepads = InputModeType.new("Gamepads", {
-	Enum.UserInputType.Gamepad1;
-	Enum.UserInputType.Gamepad2;
-	Enum.UserInputType.Gamepad3;
-	Enum.UserInputType.Gamepad4;
-	Enum.UserInputType.Gamepad5;
-	Enum.UserInputType.Gamepad6;
-	Enum.UserInputType.Gamepad7;
-	Enum.UserInputType.Gamepad8;
+	Enum.UserInputType.Gamepad1,
+	Enum.UserInputType.Gamepad2,
+	Enum.UserInputType.Gamepad3,
+	Enum.UserInputType.Gamepad4,
+	Enum.UserInputType.Gamepad5,
+	Enum.UserInputType.Gamepad6,
+	Enum.UserInputType.Gamepad7,
+	Enum.UserInputType.Gamepad8,
 
 	-- Valid KeyCodes for input binding
-	Enum.KeyCode.ButtonX;
-	Enum.KeyCode.ButtonY;
-	Enum.KeyCode.ButtonA;
-	Enum.KeyCode.ButtonB;
-	Enum.KeyCode.ButtonR1;
-	Enum.KeyCode.ButtonL1;
-	Enum.KeyCode.ButtonR2;
-	Enum.KeyCode.ButtonL2;
-	Enum.KeyCode.ButtonR3;
-	Enum.KeyCode.ButtonL3;
-	Enum.KeyCode.ButtonStart;
-	Enum.KeyCode.ButtonSelect;
-	Enum.KeyCode.DPadLeft;
-	Enum.KeyCode.DPadRight;
-	Enum.KeyCode.DPadUp;
-	Enum.KeyCode.DPadDown;
+	Enum.KeyCode.ButtonX,
+	Enum.KeyCode.ButtonY,
+	Enum.KeyCode.ButtonA,
+	Enum.KeyCode.ButtonB,
+	Enum.KeyCode.ButtonR1,
+	Enum.KeyCode.ButtonL1,
+	Enum.KeyCode.ButtonR2,
+	Enum.KeyCode.ButtonL2,
+	Enum.KeyCode.ButtonR3,
+	Enum.KeyCode.ButtonL3,
+	Enum.KeyCode.ButtonStart,
+	Enum.KeyCode.ButtonSelect,
+	Enum.KeyCode.DPadLeft,
+	Enum.KeyCode.DPadRight,
+	Enum.KeyCode.DPadUp,
+	Enum.KeyCode.DPadDown,
 })
 
-return Table.readonly(InputModeTypes)
+export type InputModeTypes = {
+	Keypad: InputModeType.InputModeType,
+	Keyboard: InputModeType.InputModeType,
+	ArrowKeys: InputModeType.InputModeType,
+	WASD: InputModeType.InputModeType,
+	Mouse: InputModeType.InputModeType,
+	KeyboardAndMouse: InputModeType.InputModeType,
+	Touch: InputModeType.InputModeType,
+	DPad: InputModeType.InputModeType,
+	Thumbsticks: InputModeType.InputModeType,
+	Gamepads: InputModeType.InputModeType,
+}
+
+return Table.readonly(InputModeTypes :: InputModeTypes)