@quenty/parttouchingcalculator 14.40.1 → 14.42.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.
 
+# [14.42.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/parttouchingcalculator@14.41.0...@quenty/parttouchingcalculator@14.42.0) (2026-07-15)
+
+**Note:** Version bump only for package @quenty/parttouchingcalculator
+
+# [14.41.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/parttouchingcalculator@14.40.1...@quenty/parttouchingcalculator@14.41.0) (2026-07-14)
+
+### Bug Fixes
+
+- **lint:** resolve selene and moonwave issues from strict conversions ([d427005](https://github.com/Quenty/NevermoreEngine/commit/d42700569ecb085fee4166c5bfdad382dd8442c2))
+
+### Features
+
+- **parttouchingcalculator:** convert package to --!strict ([0ec2478](https://github.com/Quenty/NevermoreEngine/commit/0ec2478e41ad9c4eeae331cbc00485e10e2ef8fe))
+
 ## [14.40.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/parttouchingcalculator@14.40.0...@quenty/parttouchingcalculator@14.40.1) (2026-05-30)
 
 **Note:** Version bump only for package @quenty/parttouchingcalculator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/parttouchingcalculator",
-  "version": "14.40.1",
+  "version": "14.42.0",
   "description": "Determines if parts are touching or not",
   "keywords": [
     "Roblox",
@@ -28,14 +28,14 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/binder": "14.36.1",
+    "@quenty/binder": "14.37.0",
     "@quenty/boundingboxutils": "4.5.2",
-    "@quenty/characterutils": "12.32.1",
+    "@quenty/characterutils": "12.33.0",
     "@quenty/loader": "10.11.0",
-    "@quenty/qgui": "2.4.4"
+    "@quenty/qgui": "2.5.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "598b2b62b36bdcbdbbd56f7db10c399831cc6eba"
+  "gitHead": "d577f1529aa03f5e77534145501e878bde07ca98"
 }

package/src/Shared/BinderTouchingCalculator.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Extends PartTouchingCalculator with generic binder stuff
 	@class BinderTouchingCalculator
@@ -6,6 +6,7 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local Binder = require("Binder")
 local BinderUtils = require("BinderUtils")
 local PartTouchingCalculator = require("PartTouchingCalculator")
 
@@ -13,14 +14,28 @@ local BinderTouchingCalculator = setmetatable({}, PartTouchingCalculator)
 BinderTouchingCalculator.ClassName = "BinderTouchingCalculator"
 BinderTouchingCalculator.__index = BinderTouchingCalculator
 
-function BinderTouchingCalculator.new()
-	local self = setmetatable(PartTouchingCalculator.new(), BinderTouchingCalculator)
+export type TouchingClassData<T> = {
+	Object: T,
+	Touching: { BasePart },
+}
+
+export type BinderTouchingCalculator =
+	typeof(setmetatable({} :: {}, {} :: typeof({ __index = BinderTouchingCalculator })))
+	& PartTouchingCalculator.PartTouchingCalculator
+
+function BinderTouchingCalculator.new(): BinderTouchingCalculator
+	local self: BinderTouchingCalculator = setmetatable(PartTouchingCalculator.new() :: any, BinderTouchingCalculator)
 
 	return self
 end
 
-function BinderTouchingCalculator:GetTouchingClass(binder, touchingList, ignoreObject)
-	local touching = {}
+function BinderTouchingCalculator.GetTouchingClass<T>(
+	_self: BinderTouchingCalculator,
+	binder: Binder.Binder<T>,
+	touchingList: { BasePart },
+	ignoreObject: T?
+): { TouchingClassData<T> }
+	local touching: { [T]: TouchingClassData<T> } = {}
 
 	for _, part in touchingList do
 		local object = BinderUtils.findFirstAncestor(binder, part)

package/src/Shared/PartTouchingCalculator.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Determines if parts are touching or not
 	@class PartTouchingCalculator
@@ -16,16 +16,29 @@ local PartTouchingCalculator = {}
 PartTouchingCalculator.__index = PartTouchingCalculator
 PartTouchingCalculator.ClassName = "PartTouchingCalculator"
 
+export type TouchingHumanoidData = {
+	Humanoid: Humanoid,
+	Character: Model?,
+	Player: Player?,
+	Touching: { BasePart },
+}
+
+export type PartTouchingCalculator = typeof(setmetatable({} :: {}, {} :: typeof({ __index = PartTouchingCalculator })))
+
 --[=[
 	Constructs a new PartTouchingCalculator
 ]=]
-function PartTouchingCalculator.new()
+function PartTouchingCalculator.new(): PartTouchingCalculator
 	local self = setmetatable({}, PartTouchingCalculator)
 
 	return self
 end
 
-function PartTouchingCalculator:CheckIfTouchingHumanoid(humanoid: Humanoid, parts)
+function PartTouchingCalculator.CheckIfTouchingHumanoid(
+	self: PartTouchingCalculator,
+	humanoid: Humanoid,
+	parts: { BasePart }
+): boolean
 	assert(humanoid, "Bad humanoid")
 	assert(parts, "Must have parts")
 
@@ -48,17 +61,18 @@ function PartTouchingCalculator:CheckIfTouchingHumanoid(humanoid: Humanoid, part
 
 	local dummyPart = self:GetCollidingPartFromParts(humanoidParts)
 
-	local previousProperties = {}
-	local toSet = {
+	local previousProperties: { [BasePart]: { [string]: any } } = {}
+	local toSet: { [string]: any } = {
 		CanCollide = true,
 		Anchored = false,
 	}
-	local partSet = {}
+	local partSet: { [BasePart]: boolean } = {}
 	for _, part in parts do
 		previousProperties[part] = {}
+		local anyPart = part :: any
 		for name, value in toSet do
-			previousProperties[part][name] = part[name]
-			part[name] = value
+			previousProperties[part][name] = anyPart[name]
+			anyPart[name] = value
 		end
 		partSet[part] = true
 	end
@@ -77,17 +91,22 @@ function PartTouchingCalculator:CheckIfTouchingHumanoid(humanoid: Humanoid, part
 
 	for part, properties in previousProperties do
 		for name, value in properties do
-			part[name] = value
+			(part :: any)[name] = value
 		end
 	end
 
 	return returnValue
 end
 
-function PartTouchingCalculator:GetCollidingPartFromParts(parts, relativeTo, padding)
-	relativeTo = relativeTo or CFrame.new()
+function PartTouchingCalculator.GetCollidingPartFromParts(
+	_self: PartTouchingCalculator,
+	parts: { BasePart },
+	relativeTo: CFrame?,
+	padding: number?
+): BasePart
+	local actualRelativeTo = relativeTo or CFrame.new()
 
-	local size, position = BoundingBoxUtils.getPartsBoundingBox(parts, relativeTo)
+	local size, position = BoundingBoxUtils.getPartsBoundingBox(parts, actualRelativeTo)
 
 	if padding then
 		size = size + Vector3.new(padding, padding, padding)
@@ -96,7 +115,7 @@ function PartTouchingCalculator:GetCollidingPartFromParts(parts, relativeTo, pad
 	local dummyPart = Instance.new("Part")
 	dummyPart.Name = "CollisionDetection"
 	dummyPart.Size = size
-	dummyPart.CFrame = relativeTo + relativeTo:vectorToWorldSpace(position)
+	dummyPart.CFrame = actualRelativeTo + actualRelativeTo:VectorToWorldSpace(position)
 	dummyPart.Anchored = false
 	dummyPart.CanCollide = true
 	dummyPart.Parent = Workspace
@@ -104,7 +123,12 @@ function PartTouchingCalculator:GetCollidingPartFromParts(parts, relativeTo, pad
 	return dummyPart
 end
 
-function PartTouchingCalculator:GetTouchingBoundingBox(parts, relativeTo, padding)
+function PartTouchingCalculator.GetTouchingBoundingBox(
+	self: PartTouchingCalculator,
+	parts: { BasePart },
+	relativeTo: CFrame?,
+	padding: number?
+): { BasePart }
 	local dummy = self:GetCollidingPartFromParts(parts, relativeTo, padding)
 	local touching = dummy:GetTouchingParts()
 	dummy:Destroy()
@@ -113,8 +137,12 @@ function PartTouchingCalculator:GetTouchingBoundingBox(parts, relativeTo, paddin
 end
 
 -- Expensive hull check on a list of parts (aggregating each parts touching list)
-function PartTouchingCalculator:GetTouchingHull(parts, padding)
-	local hitParts = {}
+function PartTouchingCalculator.GetTouchingHull(
+	self: PartTouchingCalculator,
+	parts: { BasePart },
+	padding: number?
+): { BasePart }
+	local hitParts: { [BasePart]: boolean } = {}
 
 	for _, part in parts do
 		for _, TouchingPart in self:GetTouching(part, padding) do
@@ -136,9 +164,13 @@ end
 	@param padding number -- studs of padding around the part
 	@return { BasePart }
 ]=]
-function PartTouchingCalculator:GetTouching(basePart, padding)
-	padding = padding or 2
-	local part
+function PartTouchingCalculator.GetTouching(
+	_self: PartTouchingCalculator,
+	basePart: BasePart,
+	padding: number?
+): { BasePart }
+	local actualPadding = padding or 2
+	local part: BasePart
 
 	if basePart:IsA("TrussPart") then
 		-- Truss parts can't be resized
@@ -155,7 +187,7 @@ function PartTouchingCalculator:GetTouching(basePart, padding)
 		part:ClearAllChildren()
 	end
 
-	part.Size = basePart.Size + Vector3.new(padding, padding, padding)
+	part.Size = basePart.Size + Vector3.new(actualPadding, actualPadding, actualPadding)
 	part.CFrame = basePart.CFrame
 	part.Anchored = false
 	part.CanCollide = true
@@ -169,11 +201,15 @@ function PartTouchingCalculator:GetTouching(basePart, padding)
 	return touching
 end
 
-function PartTouchingCalculator:GetTouchingHumanoids(touchingList)
-	local touchingHumanoids = {}
+function PartTouchingCalculator.GetTouchingHumanoids(
+	_self: PartTouchingCalculator,
+	touchingList: { BasePart }
+): { TouchingHumanoidData }
+	local touchingHumanoids: { [Humanoid]: TouchingHumanoidData } = {}
 
 	for _, part in touchingList do
-		local humanoid = part.Parent:FindFirstChildOfClass("Humanoid")
+		local parent = part.Parent
+		local humanoid = parent and parent:FindFirstChildOfClass("Humanoid")
 		if humanoid then
 			if not touchingHumanoids[humanoid] then
 				local player = CharacterUtils.getPlayerFromCharacter(humanoid)

package/src/Shared/PartTouchingRenderer.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Renders touching parts from the PartTouchingCalculator
 	@class PartTouchingRenderer
@@ -14,13 +14,15 @@ local PartTouchingRenderer = {}
 PartTouchingRenderer.__index = PartTouchingRenderer
 PartTouchingRenderer.ClassName = "PartTouchingRenderer"
 
-function PartTouchingRenderer.new()
-	local self = setmetatable({}, PartTouchingRenderer)
+export type PartTouchingRenderer = typeof(setmetatable({} :: {}, {} :: typeof({ __index = PartTouchingRenderer })))
+
+function PartTouchingRenderer.new(): PartTouchingRenderer
+	local self: PartTouchingRenderer = setmetatable({}, PartTouchingRenderer)
 
 	return self
 end
 
-function PartTouchingRenderer:RenderTouchingProps(touchingPartList)
+function PartTouchingRenderer.RenderTouchingProps(_self: PartTouchingRenderer, touchingPartList: { BasePart }): ()
 	for _, part in touchingPartList do
 		local selectionBox = Instance.new("SelectionBox")
 		selectionBox.Name = "TouchingWarning"