@quenty/inputkeymaputils 14.35.0-canary.643.622f151.0 → 14.35.0

package/CHANGELOG.md

@@ -3,7 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-# [14.35.0-canary.643.622f151.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@14.34.0...@quenty/inputkeymaputils@14.35.0-canary.643.622f151.0) (2026-01-19)
+# [14.35.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@14.34.2...@quenty/inputkeymaputils@14.35.0) (2026-01-26)
+
+
+### Bug Fixes
+
+* Fix lint ([7c77d1f](https://github.com/Quenty/NevermoreEngine/commit/7c77d1f6d95657072fc756e6f93bed1484646ad9))
+* Remove holding state from input system ([b20d6f8](https://github.com/Quenty/NevermoreEngine/commit/b20d6f88725703864fe8112517dd4a5270274e3a))
+
+
+### Features
+
+* Add Holdable option to InputKeyMapList ([0422fb6](https://github.com/Quenty/NevermoreEngine/commit/0422fb61671d80b110b06c6bf2da00fb293698bb))
+
+
+
+
+
+## [14.34.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@14.34.1...@quenty/inputkeymaputils@14.34.2) (2026-01-23)
+
+**Note:** Version bump only for package @quenty/inputkeymaputils
+
+
+
+
+
+## [14.34.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/inputkeymaputils@14.34.0...@quenty/inputkeymaputils@14.34.1) (2026-01-21)
 
 **Note:** Version bump only for package @quenty/inputkeymaputils
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/inputkeymaputils",
-  "version": "14.35.0-canary.643.622f151.0",
+  "version": "14.35.0",
   "description": "System to define rebindable key bindings and inputs for Roblox.",
   "keywords": [
     "Roblox",
@@ -30,25 +30,25 @@
   ],
   "dependencies": {
     "@quenty/baseobject": "10.9.3",
-    "@quenty/brio": "14.25.0-canary.643.622f151.0",
-    "@quenty/clienttranslator": "14.30.0-canary.643.622f151.0",
+    "@quenty/brio": "14.24.1",
+    "@quenty/clienttranslator": "14.29.2",
     "@quenty/ducktype": "5.9.3",
     "@quenty/enumutils": "3.4.5",
-    "@quenty/inputmode": "13.28.0-canary.643.622f151.0",
+    "@quenty/inputmode": "13.27.1",
     "@quenty/loader": "10.9.3",
     "@quenty/maid": "3.5.3",
-    "@quenty/observablecollection": "12.31.0-canary.643.622f151.0",
+    "@quenty/observablecollection": "12.30.2",
     "@quenty/pseudolocalize": "3.5.2",
-    "@quenty/rx": "13.24.0-canary.643.622f151.0",
+    "@quenty/rx": "13.23.1",
     "@quenty/servicebag": "11.13.6",
-    "@quenty/statestack": "14.27.0-canary.643.622f151.0",
+    "@quenty/statestack": "14.26.1",
     "@quenty/string": "3.3.6",
     "@quenty/table": "3.9.2",
-    "@quenty/valuebaseutils": "13.25.0-canary.643.622f151.0",
-    "@quenty/valueobject": "13.26.0-canary.643.622f151.0"
+    "@quenty/valuebaseutils": "13.24.1",
+    "@quenty/valueobject": "13.25.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "622f15117c0a16a8842c8015752c49d63ba96eae"
+  "gitHead": "6fd82c03003b22a03c83d00cac39fe2b2f7f8aa1"
 }

package/src/Shared/HoldableInputModel.lua

@@ -0,0 +1,217 @@
+--!strict
+--[=[
+	Tracks hold state for an input. Handles the timing logic
+	and exposes observables for hold progress.
+
+	```lua
+	local holdableInputModel = HoldableInputModel.new(1.5)
+	-- Or set it later:
+	-- holdableInputModel:SetMaxHoldDuration(1.5)
+
+	maid:GiveTask(holdableInputModel.HoldReleased:Connect(function(holdPercent)
+		print("Released at", holdPercent)
+	end))
+
+	-- When input begins
+	holdableInputModel:StartHold()
+
+	-- When input ends
+	holdableInputModel:StopHold()
+	```
+
+	@class HoldableInputModel
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local BaseObject = require("BaseObject")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local Signal = require("Signal")
+local ValueObject = require("ValueObject")
+
+local HoldableInputModel = setmetatable({}, BaseObject)
+HoldableInputModel.ClassName = "HoldableInputModel"
+HoldableInputModel.__index = HoldableInputModel
+
+export type HoldableInputModel =
+	typeof(setmetatable(
+		{} :: {
+			_maxHoldDuration: ValueObject.ValueObject<number>,
+			_holdPercent: ValueObject.ValueObject<number>,
+			_isHolding: ValueObject.ValueObject<boolean>,
+			HoldStarted: Signal.Signal<()>,
+			HoldUpdated: Signal.Signal<number>,
+			HoldReleased: Signal.Signal<number>,
+		},
+		{} :: typeof({ __index = HoldableInputModel })
+	))
+	& BaseObject.BaseObject
+
+--[=[
+	Constructs a new HoldableInputModel
+
+	@param maxHoldDuration number? -- Optional max hold duration in seconds (defaults to 1)
+	@return HoldableInputModel
+]=]
+function HoldableInputModel.new(maxHoldDuration: number?): HoldableInputModel
+	local self = setmetatable(BaseObject.new() :: any, HoldableInputModel)
+
+	self._maxHoldDuration = self._maid:Add(ValueObject.new(maxHoldDuration or 1, "number"))
+	self._holdPercent = self._maid:Add(ValueObject.new(0, "number"))
+	self._isHolding = self._maid:Add(ValueObject.new(false, "boolean"))
+
+	--[=[
+		Fires when a hold begins
+		@prop HoldStarted Signal<>
+		@within HoldableInputModel
+	]=]
+	self.HoldStarted = self._maid:Add(Signal.new())
+
+	--[=[
+		Fires when the hold percent updates
+		@prop HoldUpdated Signal<number>
+		@within HoldableInputModel
+	]=]
+	self.HoldUpdated = self._maid:Add(Signal.new())
+
+	--[=[
+		Fires when a hold is released with the final hold percent
+		@prop HoldReleased Signal<number>
+		@within HoldableInputModel
+	]=]
+	self.HoldReleased = self._maid:Add(Signal.new())
+
+	return self
+end
+
+--[=[
+	Sets the maximum hold duration in seconds
+
+	@param duration number | Observable<number>
+	@return MaidTask
+]=]
+function HoldableInputModel.SetMaxHoldDuration(
+	self: HoldableInputModel,
+	duration: number | Observable.Observable<number>
+)
+	return self._maxHoldDuration:Mount(duration)
+end
+
+--[=[
+	Gets the maximum hold duration
+
+	@return number
+]=]
+function HoldableInputModel.GetMaxHoldDuration(self: HoldableInputModel): number
+	return self._maxHoldDuration.Value
+end
+
+--[=[
+	Observes the maximum hold duration
+
+	@return Observable<number>
+]=]
+function HoldableInputModel.ObserveMaxHoldDuration(self: HoldableInputModel): Observable.Observable<number>
+	return self._maxHoldDuration:Observe()
+end
+
+--[=[
+	Observes the current hold percent (0-1)
+
+	@return Observable<number>
+]=]
+function HoldableInputModel.ObserveHoldPercent(self: HoldableInputModel): Observable.Observable<number>
+	return self._holdPercent:Observe()
+end
+
+--[=[
+	Gets the current hold percent (0-1)
+
+	@return number
+]=]
+function HoldableInputModel.GetHoldPercent(self: HoldableInputModel): number
+	return self._holdPercent.Value
+end
+
+--[=[
+	Observes whether currently holding
+
+	@return Observable<boolean>
+]=]
+function HoldableInputModel.ObserveIsHolding(self: HoldableInputModel): Observable.Observable<boolean>
+	return self._isHolding:Observe()
+end
+
+--[=[
+	Returns whether currently holding
+
+	@return boolean
+]=]
+function HoldableInputModel.IsHolding(self: HoldableInputModel): boolean
+	return self._isHolding.Value
+end
+
+--[=[
+	Starts tracking a hold. Call this when input begins.
+]=]
+function HoldableInputModel.StartHold(self: HoldableInputModel): ()
+	self._maid._holdMaid = nil
+
+	local maid = Maid.new()
+	local elapsed = 0
+	local maxDuration = self._maxHoldDuration.Value or 1
+
+	self._isHolding.Value = true
+	self._holdPercent.Value = 0
+	self.HoldStarted:Fire()
+
+	maid:GiveTask(RunService.Heartbeat:Connect(function(dt)
+		elapsed += dt
+		local newPercent = math.clamp(elapsed / maxDuration, 0, 1)
+		if self._holdPercent.Value ~= newPercent then
+			self._holdPercent.Value = newPercent
+			self.HoldUpdated:Fire(newPercent)
+		end
+	end))
+
+	maid:GiveTask(function()
+		local finalPercent = self._holdPercent.Value
+		self._holdPercent.Value = 0
+		self._isHolding.Value = false
+		self.HoldReleased:Fire(finalPercent)
+	end)
+
+	self._maid._holdMaid = maid
+end
+
+--[=[
+	Stops tracking a hold and fires HoldReleased with the final percent.
+	Call this when input ends.
+]=]
+function HoldableInputModel.StopHold(self: HoldableInputModel): ()
+	self._maid._holdMaid = nil
+end
+
+--[=[
+	Cancels a hold without firing HoldReleased.
+	Use this when the hold should be aborted (e.g., interrupted by stun).
+]=]
+function HoldableInputModel.CancelHold(self: HoldableInputModel): ()
+	if self._maid._holdMaid then
+		self._isHolding.Value = false
+		self._holdPercent.Value = 0
+		-- Clear without triggering cleanup function
+		local holdMaid = self._maid._holdMaid
+		self._maid._holdMaid = nil
+		if holdMaid and holdMaid.Destroy then
+			-- Destroy without the cleanup function firing HoldReleased
+			holdMaid._tasks = {}
+			holdMaid:Destroy()
+		end
+	end
+end
+
+return HoldableInputModel