@quenty/scrollingframe 12.18.1 → 12.20.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [12.20.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/scrollingframe@12.19.0...@quenty/scrollingframe@12.20.0) (2026-07-18)
+
+**Note:** Version bump only for package @quenty/scrollingframe
+
+# [12.19.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/scrollingframe@12.18.1...@quenty/scrollingframe@12.19.0) (2026-07-14)
+
+### Bug Fixes
+
+- **lint:** resolve selene and moonwave issues from strict conversions ([d427005](https://github.com/Quenty/NevermoreEngine/commit/d42700569ecb085fee4166c5bfdad382dd8442c2))
+
+### Features
+
+- **scrollingframe:** convert package to --!strict ([bd5908a](https://github.com/Quenty/NevermoreEngine/commit/bd5908afefafaaa181cb1d72a85176d1838adcfa))
+
 ## [12.18.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/scrollingframe@12.18.0...@quenty/scrollingframe@12.18.1) (2026-05-30)
 
 **Note:** Version bump only for package @quenty/scrollingframe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/scrollingframe",
-  "version": "12.18.1",
+  "version": "12.20.0",
   "description": "Creates an inertia based scrolling frame that is animated and has inertia frames Alternative to a Roblox ScrollingFrame with inertia scrolling and complete control over behavior and style",
   "keywords": [
     "Roblox",
@@ -29,7 +29,7 @@
   ],
   "dependencies": {
     "@quenty/loader": "10.11.0",
-    "@quenty/maid": "3.9.0",
+    "@quenty/maid": "3.10.0",
     "@quenty/signal": "7.13.1",
     "@quenty/spring": "10.12.0",
     "@quenty/table": "3.9.2"
@@ -37,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "598b2b62b36bdcbdbbd56f7db10c399831cc6eba"
+  "gitHead": "647acfad93dca41c38f59cda247d2bfc0fff36d4"
 }

package/src/Client/ScrollModel.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Scrolling model for scrolling frame
 	@class ScrollModel
@@ -15,8 +15,37 @@ ScrollModel._min = 0
 ScrollModel._max = 100
 ScrollModel._viewSize = 50
 
-function ScrollModel.new()
-	local self = setmetatable({}, ScrollModel)
+export type ScrollModel = typeof(setmetatable(
+	{} :: {
+		_min: number,
+		_max: number,
+		_viewSize: number,
+		_spring: Spring.Spring<number>,
+
+		TotalContentLength: number,
+		ViewSize: number,
+		Max: number,
+		ContentMax: number,
+		Min: number,
+		ContentMin: number,
+		Position: number,
+		BackBounceInputRange: number,
+		BackBounceRenderRange: number,
+		ContentScrollPercentSize: number,
+		RenderedContentScrollPercentSize: number,
+		ContentScrollPercent: number,
+		RenderedContentScrollPercent: number,
+		BoundedRenderPosition: number,
+		Velocity: number,
+		Target: number,
+		TargetContentScrollPercent: number,
+		AtRest: boolean,
+	},
+	{} :: typeof({ __index = ScrollModel })
+))
+
+function ScrollModel.new(): ScrollModel
+	local self: ScrollModel = setmetatable({} :: any, ScrollModel)
 
 	self._spring = Spring.new(0)
 	self._spring.Speed = 20
@@ -24,11 +53,11 @@ function ScrollModel.new()
 	return self
 end
 
-function ScrollModel:_getTimesOverBounds(position)
+function ScrollModel._getTimesOverBounds(self: ScrollModel, position: number): number
 	return self:GetDisplacementPastBounds(position) / self.BackBounceInputRange
 end
 
-function ScrollModel:GetDisplacementPastBounds(position)
+function ScrollModel.GetDisplacementPastBounds(self: ScrollModel, position: number): number
 	if position > self.ContentMax then
 		return position - self.ContentMax
 	elseif position < self.ContentMin then
@@ -38,11 +67,13 @@ function ScrollModel:GetDisplacementPastBounds(position)
 	end
 end
 
-function ScrollModel:GetScale(timesOverBounds)
+function ScrollModel.GetScale(_self: ScrollModel, timesOverBounds: number): number
 	return 1 - 0.5 ^ math.abs(timesOverBounds)
 end
 
-function ScrollModel:__index(index)
+local rawScrollModel = ScrollModel :: any
+
+rawScrollModel.__index = function(self: any, index: string): any
 	if index == "TotalContentLength" then
 		return self._max - self._min
 	elseif index == "ViewSize" then
@@ -100,15 +131,15 @@ function ScrollModel:__index(index)
 		return self._spring.Target
 	elseif index == "AtRest" then
 		return math.abs(self._spring.Target - self._spring.Position) < 1e-5 and math.abs(self._spring.Velocity) < 1e-5
-	elseif ScrollModel[index] then
-		return ScrollModel[index]
+	elseif rawScrollModel[index] then
+		return rawScrollModel[index]
 	else
 		error(string.format("[ScrollModel] - '%s' is not a valid member", tostring(index)))
 	end
 end
 
-function ScrollModel:__newindex(index, value)
-	if ScrollModel[index] or index == "_spring" then
+rawScrollModel.__newindex = function(self: any, index: string, value: any): ()
+	if rawScrollModel[index] or index == "_spring" then
 		rawset(self, index, value)
 	elseif index == "Min" or index == "ContentMin" then
 		self._min = value

package/src/Client/Scrollbar.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	@class Scrollbar
 ]=]
@@ -7,15 +7,41 @@ local require = require(script.Parent.loader).load(script)
 
 local Maid = require("Maid")
 local SCROLL_TYPE = require("SCROLL_TYPE")
+local ScrollModel = require("ScrollModel")
 local Signal = require("Signal")
 local Table = require("Table")
 
+type ScrollType = typeof(SCROLL_TYPE.Vertical)
+
+-- ScrollingFrame is still nonstrict and exports no type; type the surface we use.
+type ScrollingFrameLike = {
+	GetModel: (self: ScrollingFrameLike) -> ScrollModel.ScrollModel,
+	StartScrollbarScrolling: (
+		self: ScrollingFrameLike,
+		scrollbarContainer: Instance,
+		inputBeganObject: InputObject
+	) -> Maid.Maid,
+}
+
 local Scrollbar = {}
 Scrollbar.ClassName = "Scrollbar"
 Scrollbar.__index = Scrollbar
 
-function Scrollbar.new(gui, scrollType)
-	local self = setmetatable({}, Scrollbar)
+export type Scrollbar = typeof(setmetatable(
+	{} :: {
+		Gui: GuiObject,
+		DraggingBegan: Signal.Signal<()>,
+		_maid: Maid.Maid,
+		_container: Instance,
+		_scrollType: ScrollType,
+		_scrollingFrame: ScrollingFrameLike,
+		_model: ScrollModel.ScrollModel,
+	},
+	{} :: typeof({ __index = Scrollbar })
+))
+
+function Scrollbar.new(gui: GuiObject, scrollType: ScrollType?): Scrollbar
+	local self: Scrollbar = setmetatable({} :: any, Scrollbar)
 
 	self.Gui = gui or error("No gui")
 	self.DraggingBegan = Signal.new()
@@ -27,7 +53,7 @@ function Scrollbar.new(gui, scrollType)
 	return self
 end
 
-function Scrollbar.fromContainer(container, scrollType)
+function Scrollbar.fromContainer(container: GuiObject, scrollType: ScrollType?): Scrollbar
 	local gui = Instance.new("ImageButton")
 	gui.Size = UDim2.fromScale(1, 1)
 	gui.Name = "ScrollBar"
@@ -42,12 +68,12 @@ function Scrollbar.fromContainer(container, scrollType)
 	return Scrollbar.new(gui, scrollType)
 end
 
-function Scrollbar:SetScrollType(scrollType)
+function Scrollbar.SetScrollType(self: Scrollbar, scrollType: ScrollType): ()
 	assert(Table.contains(SCROLL_TYPE, scrollType))
 	self._scrollType = scrollType
 end
 
-function Scrollbar:SetScrollingFrame(scrollingFrame)
+function Scrollbar.SetScrollingFrame(self: Scrollbar, scrollingFrame: ScrollingFrameLike): ()
 	self._scrollingFrame = scrollingFrame or error("No scrollingFrame")
 	self._model = self._scrollingFrame:GetModel()
 
@@ -60,7 +86,7 @@ function Scrollbar:SetScrollingFrame(scrollingFrame)
 	self:UpdateRender()
 end
 
-function Scrollbar:UpdateRender()
+function Scrollbar.UpdateRender(self: Scrollbar): ()
 	if self._model.TotalContentLength > self._model.ViewSize then
 		local percentSize = self._model.RenderedContentScrollPercentSize
 		local pos = (1 - percentSize) * self._model.RenderedContentScrollPercent
@@ -81,10 +107,10 @@ function Scrollbar:UpdateRender()
 	end
 end
 
-function Scrollbar:Destroy()
-	self._maid:DoCleaning()
-	self._maid = nil
-	setmetatable(self, nil)
+function Scrollbar.Destroy(self: Scrollbar): ()
+	self._maid:DoCleaning();
+	(self :: any)._maid = nil
+	setmetatable(self :: any, nil)
 end
 
 return Scrollbar

package/src/Client/ScrollingFrame.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Creates an inertia based scrolling frame that is animated and has inertia frames
 	Alternative to a Roblox ScrollingFrame with inertia scrolling and complete control over behavior and style.
@@ -21,6 +21,26 @@ local ScrollingFrame = {}
 ScrollingFrame.ClassName = "ScrollingFrame"
 ScrollingFrame.__index = ScrollingFrame
 
+export type ScrollType = {
+	Direction: string,
+}
+
+export type ScrollingFrameOptions = {
+	OnClick: ((inputObject: InputObject) -> ())?,
+}
+
+export type ScrollingFrame = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		Gui: GuiObject,
+		_container: GuiObject,
+		_scrollType: ScrollType,
+		_scrollbars: { any },
+		_model: ScrollModel.ScrollModel,
+	},
+	{} :: typeof({ __index = ScrollingFrame })
+))
+
 --[=[
 	Creates a new ScrollingFrame which can be used. Prefer Container.Active = true so scroll wheel works.
 	Container should be in a Frame with ClipsDescendants = true
@@ -28,12 +48,12 @@ ScrollingFrame.__index = ScrollingFrame
 	@param gui BaseGui -- Gui to use
 	@return ScrollingFrame
 ]=]
-function ScrollingFrame.new(gui)
-	local self = setmetatable({}, ScrollingFrame)
+function ScrollingFrame.new(gui: GuiObject): ScrollingFrame
+	local self: ScrollingFrame = setmetatable({} :: any, ScrollingFrame)
 
 	self._maid = Maid.new()
 	self.Gui = gui or error("No Gui")
-	self._container = self.Gui.Parent or error("No container")
+	self._container = (self.Gui.Parent or error("No container")) :: GuiObject
 	self._scrollType = SCROLL_TYPE.Vertical
 
 	self._scrollbars = {}
@@ -59,12 +79,12 @@ function ScrollingFrame.new(gui)
 end
 
 -- Sets the scroll type for the frame
-function ScrollingFrame:SetScrollType(scrollType)
-	assert(Table.contains(SCROLL_TYPE, scrollType))
+function ScrollingFrame.SetScrollType(self: ScrollingFrame, scrollType: ScrollType): ()
+	assert(Table.contains(SCROLL_TYPE :: any, scrollType))
 	self._scrollType = scrollType
 end
 
-function ScrollingFrame:AddScrollbar(scrollbar)
+function ScrollingFrame.AddScrollbar(self: ScrollingFrame, scrollbar: any): ()
 	assert(scrollbar, "Bad scrollbar")
 	scrollbar:SetScrollingFrame(self)
 
@@ -72,7 +92,7 @@ function ScrollingFrame:AddScrollbar(scrollbar)
 	self._maid[scrollbar] = scrollbar
 end
 
-function ScrollingFrame:RemoveScrollbar(scrollbar)
+function ScrollingFrame.RemoveScrollbar(self: ScrollingFrame, scrollbar: any): ()
 	local index = Table.getIndex(self._scrollbars, scrollbar)
 	if index then
 		table.remove(self._scrollbars, index)
@@ -81,34 +101,34 @@ function ScrollingFrame:RemoveScrollbar(scrollbar)
 end
 
 -- Scrolls to the position in pixels offset
-function ScrollingFrame:ScrollTo(position, doNotAnimate: boolean?)
+function ScrollingFrame.ScrollTo(self: ScrollingFrame, position: number, doNotAnimate: boolean?): ()
 	self._model.Target = position
 	if doNotAnimate then
-		self._model.position = self._model.Target
+		(self._model :: any).position = self._model.Target
 		self._model.Velocity = 0
 	end
 end
 
 -- Scrolls to the top
-function ScrollingFrame:ScrollToTop(doNotAnimate: boolean?)
+function ScrollingFrame.ScrollToTop(self: ScrollingFrame, doNotAnimate: boolean?): ()
 	self:ScrollTo(self._model.Min, doNotAnimate)
 end
 
 -- Scrolls to the bottom
-function ScrollingFrame:ScrollToBottom(doNotAnimate: boolean?)
+function ScrollingFrame.ScrollToBottom(self: ScrollingFrame, doNotAnimate: boolean?): ()
 	self:ScrollTo(self._model.Max, doNotAnimate)
 end
 
-function ScrollingFrame:GetModel()
+function ScrollingFrame.GetModel(self: ScrollingFrame): ScrollModel.ScrollModel
 	return self._model
 end
 
-function ScrollingFrame:_updateScrollerSize()
-	self._model.TotalContentLength = self.Gui.AbsoluteSize[self._scrollType.Direction]
-	self._model.ViewSize = self._container.AbsoluteSize[self._scrollType.Direction]
+function ScrollingFrame._updateScrollerSize(self: ScrollingFrame): ()
+	self._model.TotalContentLength = (self.Gui.AbsoluteSize :: any)[self._scrollType.Direction]
+	self._model.ViewSize = (self._container.AbsoluteSize :: any)[self._scrollType.Direction]
 end
 
-function ScrollingFrame:_updateRender()
+function ScrollingFrame._updateRender(self: ScrollingFrame): ()
 	if self._scrollType == SCROLL_TYPE.Vertical then
 		self.Gui.Position = UDim2.new(self.Gui.Position.X, UDim.new(0, self._model.BoundedRenderPosition))
 	elseif self._scrollType == SCROLL_TYPE.Horizontal then
@@ -126,7 +146,7 @@ function ScrollingFrame:_updateRender()
 	end
 end
 
-function ScrollingFrame:StopDrag()
+function ScrollingFrame.StopDrag(self: ScrollingFrame): ()
 	local position = self._model.Position
 
 	if self._model:GetDisplacementPastBounds(position) == 0 then
@@ -141,7 +161,7 @@ function ScrollingFrame:StopDrag()
 end
 
 -- Scrolls until model is at rest
-function ScrollingFrame:_freeScroll(lowPriority)
+function ScrollingFrame._freeScroll(self: ScrollingFrame, lowPriority: boolean?): ()
 	if lowPriority and self._maid._updateMaid then
 		return
 	end
@@ -161,14 +181,14 @@ end
 
 --
 -- @param[opt=1] strength
-function ScrollingFrame:_getVelocityTracker(strength)
-	strength = strength or 1
+function ScrollingFrame._getVelocityTracker(self: ScrollingFrame, strength: number?): () -> ()
+	local actualStrength = strength or 1
 	self._model.Velocity = 0
 
 	local lastUpdate = tick()
 	local lastPos = self._model.Position
 
-	return function()
+	return function(): ()
 		local pos = self._model.Position
 		local elapsed = tick() - lastUpdate
 		local delta = lastPos - pos
@@ -177,19 +197,19 @@ function ScrollingFrame:_getVelocityTracker(strength)
 			elapsed = 0.03
 		end
 
-		self._model.Velocity = self._model.Velocity - (delta / elapsed) * strength
+		self._model.Velocity = self._model.Velocity - (delta / elapsed) * actualStrength
 		lastPos = pos
 		lastUpdate = tick()
 	end
 end
 
-function ScrollingFrame:_getInputProcessor(inputBeganObject: InputObject)
+function ScrollingFrame._getInputProcessor(self: ScrollingFrame, inputBeganObject: InputObject): (InputObject) -> number
 	local startPos = self._model.Position
 	local updateVelocity = self:_getVelocityTracker()
 	local originalPos = inputBeganObject.Position
 
-	return function(inputObject: InputObject)
-		local distance = (inputObject.Position - originalPos)[self._scrollType.Direction]
+	return function(inputObject: InputObject): number
+		local distance = ((inputObject.Position - originalPos) :: any)[self._scrollType.Direction]
 		local pos = startPos - distance
 		self._model.Position = pos
 		self._model.Target = pos
@@ -203,7 +223,7 @@ end
 
 -- Binds input to a specific GUI
 -- @return maid Maid -- To cleanup inputs
-function ScrollingFrame:BindInput(gui, options)
+function ScrollingFrame.BindInput(self: ScrollingFrame, gui: GuiObject, options: ScrollingFrameOptions?): Maid.Maid
 	local maid = Maid.new()
 
 	maid:GiveTask(gui.InputBegan:Connect(function(inputObject)
@@ -212,7 +232,7 @@ function ScrollingFrame:BindInput(gui, options)
 
 	maid:GiveTask(gui.InputChanged:Connect(function(inputObject)
 		if gui.Active and inputObject.UserInputType == Enum.UserInputType.MouseWheel then
-			self._model.Target = self._model.Target - inputObject.Position.z * 80
+			self._model.Target = self._model.Target - (inputObject.Position :: any).z * 80
 			self:_freeScroll()
 		end
 	end))
@@ -221,7 +241,11 @@ function ScrollingFrame:BindInput(gui, options)
 	return maid
 end
 
-function ScrollingFrame:StartScrolling(inputBeganObject, options)
+function ScrollingFrame.StartScrolling(
+	self: ScrollingFrame,
+	inputBeganObject: InputObject,
+	options: ScrollingFrameOptions?
+): ()
 	if inputBeganObject.UserInputState ~= Enum.UserInputState.Begin then
 		-- Touch events moving into GUIs occur sometimes
 		return
@@ -262,7 +286,7 @@ function ScrollingFrame:StartScrolling(inputBeganObject, options)
 			end
 		end)
 
-		maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject, _)
+		maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject: InputObject, _)
 			if inputObject == inputBeganObject then
 				self:StopDrag()
 			end
@@ -276,7 +300,11 @@ function ScrollingFrame:StartScrolling(inputBeganObject, options)
 	end
 end
 
-function ScrollingFrame:StartScrollbarScrolling(scrollbarContainer, inputBeganObject)
+function ScrollingFrame.StartScrollbarScrolling(
+	self: ScrollingFrame,
+	scrollbarContainer: GuiObject,
+	inputBeganObject: InputObject
+): Maid.Maid
 	assert(scrollbarContainer, "Bad scrollbarContainer")
 	assert(inputBeganObject, "Bad inputBeganObject")
 
@@ -286,12 +314,12 @@ function ScrollingFrame:StartScrollbarScrolling(scrollbarContainer, inputBeganOb
 	local startPercent = self._model.ContentScrollPercent
 	local updateVelocity = self:_getVelocityTracker(0.25)
 
-	maid:GiveTask(UserInputService.InputChanged:Connect(function(inputObject)
+	maid:GiveTask(UserInputService.InputChanged:Connect(function(inputObject: InputObject)
 		if inputObject.UserInputType == Enum.UserInputType.MouseMovement then
 			local direction = self._scrollType.Direction
-			local offset = (inputObject.Position - startPosition)[direction]
+			local offset = ((inputObject.Position - startPosition) :: any)[direction]
 			local percent = offset
-				/ (scrollbarContainer.AbsoluteSize[direction] * (1 - self._model.ContentScrollPercentSize))
+				/ ((scrollbarContainer.AbsoluteSize :: any)[direction] * (1 - self._model.ContentScrollPercentSize))
 			self._model.ContentScrollPercent = startPercent + percent
 			self._model.TargetContentScrollPercent = self._model.ContentScrollPercent
 
@@ -300,7 +328,7 @@ function ScrollingFrame:StartScrollbarScrolling(scrollbarContainer, inputBeganOb
 		end
 	end))
 
-	maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject)
+	maid:GiveTask(UserInputService.InputEnded:Connect(function(inputObject: InputObject)
 		if inputObject == inputBeganObject then
 			self:StopDrag()
 		end
@@ -311,10 +339,10 @@ function ScrollingFrame:StartScrollbarScrolling(scrollbarContainer, inputBeganOb
 	return maid
 end
 
-function ScrollingFrame:Destroy()
-	self._maid:DoCleaning()
-	self._maid = nil
-	setmetatable(self, nil)
+function ScrollingFrame.Destroy(self: ScrollingFrame): ()
+	self._maid:DoCleaning();
+	(self :: any)._maid = nil
+	setmetatable(self :: any, nil)
 end
 
 return ScrollingFrame