@quenty/promise 10.10.1 → 10.10.2

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.
 
+## [10.10.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/promise@10.10.1...@quenty/promise@10.10.2) (2025-04-05)
+
+
+### Bug Fixes
+
+* Add types to packages ([2374fb2](https://github.com/Quenty/NevermoreEngine/commit/2374fb2b043cfbe0e9b507b3316eec46a4e353a0))
+
+
+
+
+
 ## [10.10.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/promise@10.10.0...@quenty/promise@10.10.1) (2025-03-21)
 
 **Note:** Version bump only for package @quenty/promise

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/promise",
-  "version": "10.10.1",
+  "version": "10.10.2",
   "description": "Promise implementation for Roblox",
   "keywords": [
     "Roblox",
@@ -25,13 +25,13 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/deferred": "^2.2.0",
-    "@quenty/loader": "^10.8.0",
-    "@quenty/maid": "^3.4.0",
-    "@quenty/math": "^2.7.1"
+    "@quenty/deferred": "^2.2.1",
+    "@quenty/loader": "^10.8.1",
+    "@quenty/maid": "^3.4.1",
+    "@quenty/math": "^2.7.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6b7c3e15e60cdb185986207b574e2b5591261e7a"
+  "gitHead": "78c3ac0ab08dd18085b6e6e6e4f745e76ed99f68"
 }

package/src/Shared/Promise.lua

@@ -1,3 +1,4 @@
+--!nocheck
 --[=[
 	Promises, but without error handling as this screws with stack traces, using Roblox signals
 
@@ -12,19 +13,34 @@ local HttpService = game:GetService("HttpService")
 local ENABLE_TRACEBACK = false
 local _emptyRejectedPromise = nil
 local _emptyFulfilledPromise = nil
-local EMPTY_PACKED_TUPLE = table.freeze({ n = 0; })
+local EMPTY_PACKED_TUPLE = table.freeze({ n = 0 })
 
 local Promise = {}
 Promise.ClassName = "Promise"
 Promise.__index = Promise
 
+export type Resolve<T...> = (T...) -> ()
+export type Reject = (...any) -> ()
+export type ResolveReject<T...> = (Resolve<T...>, Reject) -> ()
+
+export type Promise<T...> = typeof(setmetatable(
+	{} :: {
+		_fulfilled: any?,
+		_rejected: any?,
+		_unconsumedException: boolean,
+		_pendingExecuteList: { any }?,
+		_source: string,
+	},
+	Promise
+))
+
 --[=[
 	Determines whether a value is a promise or not.
 
 	@param value any
 	@return boolean
 ]=]
-function Promise.isPromise(value)
+function Promise.isPromise(value: any): boolean
 	return type(value) == "table" and value.ClassName == "Promise"
 end
 
@@ -37,13 +53,13 @@ end
 	::
 
 	@param func (resolve: (...) -> (), reject: (...) -> ()) -> ()?
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.new(func)
+function Promise.new<T...>(func: ResolveReject<T...>?): Promise<T...>
 	local self = setmetatable({
-		_pendingExecuteList = {};
-		_unconsumedException = true;
-		_source = ENABLE_TRACEBACK and debug.traceback("Promise.new()", 2) or "";
+		_pendingExecuteList = {},
+		_unconsumedException = true,
+		_source = ENABLE_TRACEBACK and debug.traceback("Promise.new()", 2) or "",
 	}, Promise)
 
 	if type(func) == "function" then
@@ -57,9 +73,9 @@ end
 	Initializes a new promise with the given function in a spawn wrapper.
 
 	@param func (resolve: (...) -> (), reject: (...) -> ()) -> ()?
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.spawn(func)
+function Promise.spawn<T...>(func: ResolveReject<T...>): Promise<T...>
 	local self = Promise.new()
 
 	task.spawn(func, self:_getResolveReject())
@@ -72,9 +88,9 @@ end
 
 	@param seconds number
 	@param func (resolve: (...) -> (), reject: (...) -> ()) -> ()?
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.delay(seconds, func)
+function Promise.delay<T...>(seconds: number, func: ResolveReject<T...>): Promise<T...>
 	assert(type(seconds) == "number", "Bad seconds")
 	assert(type(func) == "function", "Bad func")
 
@@ -89,9 +105,9 @@ end
 	Initializes a new promise with the given function in a deferred wrapper.
 
 	@param func (resolve: (...) -> (), reject: (...) -> ()) -> ()?
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.defer(func)
+function Promise.defer<T...>(func: ResolveReject<T...>): Promise<T...>
 	local self = Promise.new()
 
 	-- Just the function part of the resolve/reject protocol!
@@ -104,9 +120,9 @@ end
 	Returns a resolved promise with the following values
 
 	@param ... Values to resolve to
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.resolved(...)
+function Promise.resolved<T...>(...: T...): Promise<T...>
 	local n = select("#", ...)
 	if n == 0 then
 		-- Reuse promise here to save on calls to Promise.resolved()
@@ -129,9 +145,9 @@ end
 	Returns a rejected promise with the following values
 
 	@param ... Values to reject to
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise.rejected(...)
+function Promise.rejected<T...>(...): Promise<()>
 	local n = select("#", ...)
 	if n == 0 then
 		-- Reuse promise here to save on calls to Promise.rejected()
@@ -148,7 +164,7 @@ end
 
 	@return bool -- True if pending, false otherwise
 ]=]
-function Promise:IsPending()
+function Promise.IsPending<T...>(self: Promise<T...>): boolean
 	return self._pendingExecuteList ~= nil
 end
 
@@ -157,7 +173,7 @@ end
 
 	@return bool -- True if fulfilled
 ]=]
-function Promise:IsFulfilled()
+function Promise.IsFulfilled<T...>(self: Promise<T...>): boolean
 	return self._fulfilled ~= nil
 end
 
@@ -166,7 +182,7 @@ end
 
 	@return bool -- True if rejected
 ]=]
-function Promise:IsRejected()
+function Promise.IsRejected<T...>(self: Promise<T...>): boolean
 	return self._rejected ~= nil
 end
 
@@ -177,11 +193,11 @@ end
 	@yields
 	@return T
 ]=]
-function Promise:Wait()
+function Promise.Wait<T...>(self: Promise<T...>): T...
 	if self._fulfilled then
 		return table.unpack(self._fulfilled, 1, self._fulfilled.n)
 	elseif self._rejected then
-		return error(tostring(self._rejected[1]), 2)
+		error(tostring(self._rejected[1]), 2)
 	else
 		local waitingCoroutine = coroutine.running()
 
@@ -194,14 +210,15 @@ function Promise:Wait()
 		coroutine.yield()
 
 		if self._rejected then
-			return error(tostring(self._rejected[1]), 2)
-		else
+			error(tostring(self._rejected[1]), 2)
+		elseif self._fulfilled then
 			return table.unpack(self._fulfilled, 1, self._fulfilled.n)
+		else
+			error("Bad state")
 		end
 	end
 end
 
-
 --[=[
 	Yields until the promise is complete, then returns a boolean indicating
 	the result, followed by the values from the promise.
@@ -209,7 +226,7 @@ end
 	@yields
 	@return boolean, T
 ]=]
-function Promise:Yield()
+function Promise.Yield<T...>(self: Promise<T...>): (boolean, T...)
 	if self._fulfilled then
 		return true, table.unpack(self._fulfilled, 1, self._fulfilled.n)
 	elseif self._rejected then
@@ -235,13 +252,12 @@ function Promise:Yield()
 	end
 end
 
-
 --[=[
 	Promise resolution procedure, resolves the given values
 
 	@param ... T
 ]=]
-function Promise:Resolve(...)
+function Promise:Resolve<T...>(...: T...)
 	if not self._pendingExecuteList then
 		return
 	end
@@ -253,7 +269,8 @@ function Promise:Resolve(...)
 		self:Reject("TypeError: Resolved to self")
 	elseif Promise.isPromise(...) then
 		if len > 1 then
-			local message = string.format("When resolving a promise, extra arguments are discarded! See:\n\n%s", self._source)
+			local message =
+				string.format("When resolving a promise, extra arguments are discarded! See:\n\n%s", self._source)
 			warn(message)
 		end
 
@@ -270,7 +287,6 @@ function Promise:Resolve(...)
 						self:_reject(table.pack(...))
 					end
 				end,
-				nil
 			}
 		elseif promise2._rejected then -- rejected
 			promise2._unconsumedException = false
@@ -282,7 +298,8 @@ function Promise:Resolve(...)
 		end
 	elseif type(...) == "function" then
 		if len > 1 then
-			local message = string.format("When resolving a function, extra arguments are discarded! See:\n\n%s", self._source)
+			local message =
+				string.format("When resolving a function, extra arguments are discarded! See:\n\n%s", self._source)
 			warn(message)
 		end
 
@@ -301,7 +318,7 @@ end
 	@param values { T } -- Params to fulfil with
 	@private
 ]]
-function Promise:_fulfill(values)
+function Promise._fulfill<T...>(self: Promise<T...>, values)
 	if not self._pendingExecuteList then
 		return
 	end
@@ -310,7 +327,7 @@ function Promise:_fulfill(values)
 
 	local list = self._pendingExecuteList
 	self._pendingExecuteList = nil
-	for _, data in pairs(list) do
+	for _, data in list do
 		self:_executeThen(unpack(data))
 	end
 end
@@ -319,11 +336,11 @@ end
 	Rejects the promise with the values given
 	@param ... T -- Params to reject with
 ]=]
-function Promise:Reject(...)
+function Promise.Reject<T...>(self: Promise<T...>, ...)
 	self:_reject(table.pack(...))
 end
 
-function Promise:_reject(values)
+function Promise._reject<T...>(self: Promise<T...>, values)
 	if not self._pendingExecuteList then
 		return
 	end
@@ -332,7 +349,7 @@ function Promise:_reject(values)
 
 	local list = self._pendingExecuteList
 	self._pendingExecuteList = nil
-	for _, data in pairs(list) do
+	for _, data in list do
 		self:_executeThen(unpack(data))
 	end
 
@@ -342,10 +359,12 @@ function Promise:_reject(values)
 			-- Yield to end of frame, giving control back to Roblox.
 			-- This is the equivalent of giving something back to a task manager.
 			if self._unconsumedException then
-				local errOutput = self:_toHumanReadable(self._rejected[1])
+				local errOutput = self:_toHumanReadable(values[1])
 
 				if ENABLE_TRACEBACK then
-					warn(string.format("[Promise] - Uncaught exception in promise\n\n%q\n\n%s", errOutput, self._source))
+					warn(
+						string.format("[Promise] - Uncaught exception in promise\n\n%q\n\n%s", errOutput, self._source)
+					)
 				else
 					warn(string.format("[Promise] - Uncaught exception in promise: %q", errOutput))
 				end
@@ -354,7 +373,7 @@ function Promise:_reject(values)
 	end
 end
 
-function Promise:_toHumanReadable(data)
+function Promise._toHumanReadable<T...>(_self: Promise<T...>, data: any): string
 	if type(data) == "table" then
 		local errOutput
 		local ok = pcall(function()
@@ -387,9 +406,9 @@ end
 
 	@param onFulfilled function -- Called if/when fulfilled with parameters
 	@param onRejected function -- Called if/when rejected with parameters
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise:Then(onFulfilled, onRejected)
+function Promise.Then<T...>(self: Promise<T...>, onFulfilled, onRejected)
 	if type(onRejected) == "function" then
 		self._unconsumedException = false
 	end
@@ -411,9 +430,9 @@ end
 
 	@param onFulfilled function
 	@param onRejected function
-	@return Promise<T> -- Returns self
+	@return Promise<T...> -- Returns self
 ]=]
-function Promise:Tap(onFulfilled, onRejected)
+function Promise.Tap<T...>(self: Promise<T...>, onFulfilled, onRejected)
 	-- Run immediately like then, but we return something safer!
 	local result = self:Then(onFulfilled, onRejected)
 	if result == self then
@@ -443,9 +462,9 @@ end
 	Executes upon pending stop
 
 	@param func function
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise:Finally(func)
+function Promise.Finally<T...>(self: Promise<T...>, func)
 	return self:Then(func, func)
 end
 
@@ -453,17 +472,16 @@ end
 	Catch errors from the promise
 
 	@param onRejected function
-	@return Promise<T>
+	@return Promise<T...>
 ]=]
-function Promise:Catch(onRejected)
+function Promise.Catch<T...>(self: Promise<T...>, onRejected)
 	return self:Then(nil, onRejected)
 end
 
-
 --[=[
 	Rejects the current promise. Utility left for Maid task
 ]=]
-function Promise:Destroy()
+function Promise.Destroy<T...>(self: Promise<T...>)
 	self:_reject(EMPTY_PACKED_TUPLE)
 end
 
@@ -477,7 +495,7 @@ end
 	@return boolean -- true if resolved, false otherwise.
 	@return any
 ]=]
-function Promise:GetResults()
+function Promise.GetResults<T...>(self: Promise<T...>): (boolean, T...)
 	if self._rejected then
 		return false, table.unpack(self._rejected, 1, self._rejected.n)
 	elseif self._fulfilled then
@@ -487,7 +505,7 @@ function Promise:GetResults()
 	end
 end
 
-function Promise:_getResolveReject()
+function Promise._getResolveReject<T...>(self: Promise<T...>): (Resolve<T...>, Reject)
 	return function(...)
 		self:Resolve(...)
 	end, function(...)
@@ -500,10 +518,10 @@ end
 
 	@param onFulfilled function?
 	@param onRejected function?
-	@param promise2 Promise<T>? -- May be nil. If it is, then we have the option to return self
+	@param promise2 Promise<T...>? -- May be nil. If it is, then we have the option to return self
 	@return Promise
 ]=]
-function Promise:_executeThen(onFulfilled, onRejected, promise2)
+function Promise._executeThen<T...>(self: Promise<T...>, onFulfilled, onRejected, promise2)
 	if self._fulfilled then
 		if type(onFulfilled) == "function" then
 			-- If either onFulfilled or onRejected returns a value x, run
@@ -579,4 +597,4 @@ _emptyFulfilledPromise:_fulfill(EMPTY_PACKED_TUPLE)
 _emptyRejectedPromise = Promise.new()
 _emptyRejectedPromise:_reject(EMPTY_PACKED_TUPLE)
 
-return Promise
+return Promise

package/src/Shared/PromiseRetryUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class PromiseRetryUtils
 ]=]
@@ -9,7 +10,21 @@ local Math = require("Math")
 
 local PromiseRetryUtils = {}
 
-function PromiseRetryUtils.retry(callback, options)
+export type RetryOptions = {
+	initialWaitTime: number,
+	maxAttempts: number,
+	printWarning: boolean,
+}
+
+--[=[
+	Returns a promise that will retry the given callback until it succeeds or the max attempts
+	is reached.
+
+	@param callback function -- Callback that returns a promise
+	@param options RetryOptions -- Options for retrying
+	@return Promise<T>
+]=]
+function PromiseRetryUtils.retry<T...>(callback: () -> Promise.Promise<T...>, options: RetryOptions): Promise.Promise<T...>
 	assert(type(options.initialWaitTime) == "number", "Bad initialWaitTime")
 	assert(type(options.maxAttempts) == "number", "Bad maxAttempts")
 	assert(type(options.printWarning) == "boolean", "Bad printWarning")
@@ -39,7 +54,11 @@ function PromiseRetryUtils.retry(callback, options)
 		end
 
 		isLoopResolved = true
-		local errorMessage = string.format("Attempted request %d times before failing with error", tostring(lastResults[2]))
+		local errorMessage = string.format(
+			"Attempted request %d times before failing with error %s",
+			options.maxAttempts,
+			tostring(lastResults[2])
+		)
 		promise:Reject(errorMessage, table.unpack(lastResults, 3, lastResults.n))
 	end)
 

package/src/Shared/PromiseUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Utility methods for promise
 	@class PromiseUtils
@@ -6,6 +7,7 @@
 local require = require(script.Parent.loader).load(script)
 
 local Promise = require("Promise")
+local _Signal = require("Signal")
 
 local PromiseUtils = {}
 
@@ -14,7 +16,7 @@ local PromiseUtils = {}
 	@param promises { Promise<T> }
 	@return Promise<T> -- Promise that resolves with first result
 ]=]
-function PromiseUtils.any(promises)
+function PromiseUtils.any<T...>(promises: { Promise.Promise<T...> }): Promise.Promise<T...>
 	local returnPromise = Promise.new()
 
 	local function resolve(...)
@@ -25,7 +27,7 @@ function PromiseUtils.any(promises)
 		returnPromise:Reject(...)
 	end
 
-	for _, promise in pairs(promises) do
+	for _, promise in promises do
 		promise:Then(resolve, reject)
 	end
 
@@ -38,7 +40,7 @@ end
 	@param seconds number
 	@return Promise
 ]=]
-function PromiseUtils.delayed(seconds)
+function PromiseUtils.delayed(seconds: number): Promise.Promise<()>
 	assert(type(seconds) == "number", "Bad seconds")
 
 	return Promise.delay(seconds, function(resolve, _reject)
@@ -57,7 +59,7 @@ end
 	@param promises { Promise<T> }
 	@return Promise<T>
 ]=]
-function PromiseUtils.all(promises)
+function PromiseUtils.all<T>(promises: { Promise.Promise<T> }): Promise.Promise<T>
 	if #promises == 0 then
 		return Promise.resolved()
 	elseif #promises == 1 then
@@ -81,14 +83,20 @@ function PromiseUtils.all(promises)
 		end
 	end
 
-	for index, promise in pairs(promises) do
+	for index, promise in promises do
 		promise:Then(syncronize(index, true), syncronize(index, false))
 	end
 
 	return returnPromise
 end
 
-function PromiseUtils.firstSuccessOrLastFailure(promises)
+--[=[
+	Keeps on trying promises until one of them succeeds, or reports
+	the last failure.
+
+	@param promises { Promise<T> }
+]=]
+function PromiseUtils.firstSuccessOrLastFailure<T...>(promises: { Promise.Promise<T...> }): Promise.Promise<T...>
 	if #promises == 0 then
 		return Promise.resolved()
 	elseif #promises == 1 then
@@ -109,10 +117,12 @@ function PromiseUtils.firstSuccessOrLastFailure(promises)
 			if remainingCount == 0 then
 				return returnPromise:Reject(...)
 			end
+
+			return
 		end
 	end
 
-	for _, promise in pairs(promises) do
+	for _, promise in promises do
 		promise:Then(syncronize(true), syncronize(false))
 	end
 
@@ -125,13 +135,13 @@ end
 	@param stateTable any
 	@return Promise<any>
 ]=]
-function PromiseUtils.combine(stateTable)
+function PromiseUtils.combine(stateTable: any): Promise.Promise<any>
 	assert(type(stateTable) == "table", "Bad stateTable")
 
 	local remainingCount = 0
 	local results = {}
 
-	for key, value in pairs(stateTable) do
+	for key, value in stateTable do
 		if Promise.isPromise(value) then
 			remainingCount = remainingCount + 1
 		else
@@ -159,7 +169,7 @@ function PromiseUtils.combine(stateTable)
 		end
 	end
 
-	for key, value in pairs(stateTable) do
+	for key, value in stateTable do
 		if Promise.isPromise(value) then
 			value:Then(syncronize(key, true), syncronize(key, false))
 		end
@@ -175,7 +185,7 @@ end
 	@param promise Promise<T>
 	@return Promise<T>
 ]=]
-function PromiseUtils.invert(promise)
+function PromiseUtils.invert<T...>(promise: Promise.Promise<T...>): Promise.Promise<T...>
 	if promise:IsPending() then
 		return promise:Then(function(...)
 			return Promise.rejected(...)
@@ -183,7 +193,7 @@ function PromiseUtils.invert(promise)
 			return Promise.resolved(...)
 		end)
 	else
-		local results = {promise:GetResults()}
+		local results = { promise:GetResults() }
 		if results[1] then
 			return Promise.rejected(unpack(results, 2))
 		else
@@ -198,12 +208,14 @@ end
 	@param signal Signal<T>
 	@return Promise<T>
 ]=]
-function PromiseUtils.fromSignal(signal)
+function PromiseUtils.fromSignal<T...>(signal: _Signal.Signal<T...>): Promise.Promise<T...>
 	local promise = Promise.new()
-	local conn
+	local conn: _Signal.Connection<T...>?
 
 	promise:Finally(function()
-		conn:Disconnect()
+		if conn then
+			conn:Disconnect()
+		end
 		conn = nil
 	end)
 
@@ -222,7 +234,7 @@ end
 	@param fromPromise Promise<T>
 	@return Promise<T>
 ]=]
-function PromiseUtils.timeout(timeoutTime, fromPromise)
+function PromiseUtils.timeout<T...>(timeoutTime: number, fromPromise: Promise.Promise<T...>): Promise.Promise<T...>
 	assert(type(timeoutTime) == "number", "Bad timeoutTime")
 	assert(fromPromise, "Bad fromPromise")
 

package/src/Shared/Utility/PendingPromiseTracker.lua

@@ -1,18 +1,30 @@
+--!strict
 --[=[
 	Tracks pending promises
 	@class PendingPromiseTracker
 ]=]
 
+local require = require(script.Parent.loader).load(script)
+
+local _Promise = require("Promise")
+
 local PendingPromiseTracker = {}
 PendingPromiseTracker.ClassName = "PendingPromiseTracker"
 PendingPromiseTracker.__index = PendingPromiseTracker
 
+export type PendingPromiseTracker<T...> = typeof(setmetatable(
+	{} :: {
+		_pendingPromises: { [_Promise.Promise<T...>]: true },
+	},
+	PendingPromiseTracker
+))
+
 --[=[
 	Returns a new pending promise tracker
 
 	@return PendingPromiseTracker<T>
 ]=]
-function PendingPromiseTracker.new()
+function PendingPromiseTracker.new<T...>(): PendingPromiseTracker<T...>
 	local self = setmetatable({}, PendingPromiseTracker)
 
 	self._pendingPromises = {}
@@ -22,10 +34,8 @@ end
 
 --[=[
 	Adds a new promise to the tracker. If it's not pending it will not add.
-
-	@param promise Promise<T>
 ]=]
-function PendingPromiseTracker:Add(promise)
+function PendingPromiseTracker.Add<T...>(self: PendingPromiseTracker<T...>, promise: _Promise.Promise<T...>)
 	if promise:IsPending() then
 		self._pendingPromises[promise] = true
 		promise:Finally(function()
@@ -36,12 +46,10 @@ end
 
 --[=[
 	Gets all of the promises that are pending
-
-	@return { Promise<T> }
 ]=]
-function PendingPromiseTracker:GetAll()
-	local promises = {}
-	for promise, _ in pairs(self._pendingPromises) do
+function PendingPromiseTracker.GetAll<T...>(self: PendingPromiseTracker<T...>): { _Promise.Promise<T...> }
+	local promises: { _Promise.Promise<T...> } = {}
+	for promise: any, _ in self._pendingPromises do
 		table.insert(promises, promise)
 	end
 	return promises

package/src/Shared/Utility/PromiseInstanceUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class PromiseInstanceUtils
 ]=]
@@ -15,7 +16,7 @@ local PromiseInstanceUtils = {}
 	@param instance Instance
 	@return Promise
 ]=]
-function PromiseInstanceUtils.promiseRemoved(instance)
+function PromiseInstanceUtils.promiseRemoved(instance: Instance): Promise.Promise<()>
 	assert(instance:IsDescendantOf(game))
 
 	local maid = Maid.new()

package/src/Shared/Utility/promiseChild.lua

@@ -17,14 +17,19 @@ local Promise = require("Promise")
 	@return Promise<Instance>
 	@within promiseChild
 ]=]
-return function(parent, name, timeOut)
+return function(parent: Instance, name: string, timeOut: number?): Promise.Promise<Instance>
 	local result = parent:FindFirstChild(name)
 	if result then
 		return Promise.resolved(result)
 	end
 
 	return Promise.spawn(function(resolve, reject)
-		local child = parent:WaitForChild(name, timeOut)
+		local child: Instance?
+		if timeOut then
+			child = parent:WaitForChild(name, timeOut)
+		else
+			child = parent:WaitForChild(name)
+		end
 
 		if child then
 			resolve(child)

package/src/Shared/Utility/promisePropertyValue.lua

@@ -20,7 +20,7 @@ local Promise = require("Promise")
 	@return Promise<Instance>
 	@within promisePropertyValue
 ]=]
-return function(instance, propertyName)
+return function(instance: Instance, propertyName: string)
 	assert(typeof(instance) == "Instance", "Bad instance")
 	assert(type(propertyName) == "string", "Bad propertyName")
 

package/src/Shared/Utility/promiseWait.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Wraps the task.delay() API in a promise
 
@@ -8,7 +9,7 @@ local require = require(script.Parent.loader).load(script)
 
 local Promise = require("Promise")
 
-return function(time)
+return function(time: number): Promise.Promise<()>
 	return Promise.new(function(resolve, _)
 		task.delay(time, function()
 			resolve()