@quenty/observablecollection 12.20.0 → 12.20.1

package/src/Shared/ObservableMap.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	A list that can be observed for blend and other components
 	@class ObservableMap
@@ -13,17 +14,59 @@ local Signal = require("Signal")
 local ValueObject = require("ValueObject")
 local RxBrioUtils = require("RxBrioUtils")
 local DuckTypeUtils = require("DuckTypeUtils")
+local _SortFunctionUtils = require("SortFunctionUtils")
 
 local ObservableMap = {}
 ObservableMap.ClassName = "ObservableMap"
 ObservableMap.__index = ObservableMap
 
+export type ObservableMap<TKey, TValue> = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_map: { [TKey]: TValue },
+		_keySubTable: any, -- ObservableSubscriptionTable.ObservableSubscriptionTable<TKey>,
+		_countValue: ValueObject.ValueObject<number>,
+
+		--[=[
+			Fires when a key is added
+			@readonly
+			@prop KeyAdded Signal<TKey, TValue?>
+			@within ObservableMap
+		]=]
+		KeyAdded: Signal.Signal<(TKey, TValue)>,
+
+		--[=[
+			Fires when a key is removed
+			@readonly
+			@prop KeyRemoved Signal<TKey>
+			@within ObservableMap
+		]=]
+		KeyRemoved: Signal.Signal<TKey>,
+
+		--[=[
+			Fires when a key value changes, including add and remove.
+			@readonly
+			@prop KeyValueChanged Signal<(TKey, TValue?, TValue?)>
+			@within ObservableMap
+		]=]
+		KeyValueChanged: Signal.Signal<(TKey, TValue?, TValue?)>,
+
+		--[=[
+			Fires when the count changes.
+			@prop CountChanged Signal.Signal<number>
+			@within ObservableMap
+		]=]
+		CountChanged: Signal.Signal<number>,
+	},
+	ObservableMap
+))
+
 --[=[
 	Constructs a new ObservableMap
 	@return ObservableMap<TKey, TValue>
 ]=]
-function ObservableMap.new()
-	local self = setmetatable({}, ObservableMap)
+function ObservableMap.new<TKey, TValue>(): ObservableMap<TKey, TValue>
+	local self: any = setmetatable({} :: any, ObservableMap)
 
 	self._maid = Maid.new()
 	self._map = {}
@@ -31,35 +74,9 @@ function ObservableMap.new()
 	self._keySubTable = self._maid:Add(ObservableSubscriptionTable.new())
 	self._countValue = self._maid:Add(ValueObject.new(0, "number"))
 
---[=[
-	Fires when a key is added
-	@readonly
-	@prop KeyAdded Signal<TKey>
-	@within ObservableMap
-]=]
 	self.KeyAdded = self._maid:Add(Signal.new()) -- :Fire(key, value)
-
---[=[
-	Fires when a key is removed
-	@readonly
-	@prop KeyRemoved Signal<TKey>
-	@within ObservableMap
-]=]
 	self.KeyRemoved = self._maid:Add(Signal.new()) -- :Fire(key)
-
---[=[
-	Fires when a key value changes, including add and remove.
-	@readonly
-	@prop KeyValueChanged Signal<(TKey, TValue, TValue)>
-	@within ObservableMap
-]=]
 	self.KeyValueChanged = self._maid:Add(Signal.new()) -- :Fire(key, value, oldValue)
-
---[=[
-	Fires when the count changes.
-	@prop CountChanged RBXScriptSignal
-	@within ObservableMap
-]=]
 	self.CountChanged = self._countValue.Changed
 
 	return self
@@ -70,7 +87,7 @@ end
 	@param value any
 	@return boolean
 ]=]
-function ObservableMap.isObservableMap(value)
+function ObservableMap.isObservableMap(value: any): boolean
 	return DuckTypeUtils.isImplementation(ObservableMap, value)
 end
 
@@ -79,70 +96,74 @@ end
 
 	@return (T) -> ((T, nextIndex: any) -> ...any, T?)
 ]=]
-function ObservableMap:__iter()
+function ObservableMap.__iter<TKey, TValue>(self: ObservableMap<TKey, TValue>): ...any
 	return pairs(self._map)
 end
 
-
 --[=[
 	Observes all keys in the map
 	@return Observable<Brio<TKey>>
 ]=]
-function ObservableMap:ObserveKeysBrio()
-	return self:_observeKeyValueChanged(function(key, _value)
+function ObservableMap.ObserveKeysBrio<TKey, TValue>(self: ObservableMap<TKey, TValue>): Observable.Observable<Brio.Brio<TKey>>
+	return self:_observeKeyValueChanged(function(key: TKey, _value: TValue)
 		return Brio.new(key)
-	end)
+	end) :: any
 end
 
 --[=[
 	Observes all keys in the map
 	@return Observable<Brio<TKey>>
 ]=]
-function ObservableMap:ObserveValuesBrio()
-	return self:_observeKeyValueChanged(function(_key, value)
+function ObservableMap.ObserveValuesBrio<TKey, TValue>(self: ObservableMap<TKey, TValue>): Observable.Observable<Brio.Brio<TValue>>
+	return self:_observeKeyValueChanged(function(_key: TKey, value: TValue)
 		return Brio.new(value)
-	end)
+	end) :: any
 end
 
 --[=[
 	Observes all keys in the map
 	@return Observable<Brio<(TKey, TValue)>>
 ]=]
-function ObservableMap:ObservePairsBrio()
-	return self:_observeKeyValueChanged(function(key, value)
+function ObservableMap.ObservePairsBrio<TKey, TValue>(
+	self: ObservableMap<TKey, TValue>
+): Observable.Observable<Brio.Brio<(TKey, TValue)>>
+	return self:_observeKeyValueChanged(function(key: TKey, value: TValue)
 		return Brio.new(key, value)
 	end)
 end
 
-function ObservableMap:_observeKeyValueChanged(packValue)
+function ObservableMap._observeKeyValueChanged<TKey, TValue>(
+	self: ObservableMap<TKey, TValue>,
+	packValue: (TKey, TValue) -> any
+): Observable.Observable<Brio.Brio<(TKey, TValue)>>
 	return Observable.new(function(sub)
 		local maid = Maid.new()
 
-		local function handleValue(key, value)
+		local function handleValue(key: TKey, value: TValue?, _oldValue: TValue?)
 			if value ~= nil then
 				local brio = packValue(key, value)
-				maid[key] = brio
+				maid[key :: any] = brio
 				sub:Fire(brio)
 			else
-				maid[key] = nil
+				maid[key :: any] = nil
 			end
 		end
 
-		for key, value in pairs(self._map) do
+		for key, value in self._map do
 			handleValue(key, value)
 		end
 
 		local conn = self.KeyValueChanged:Connect(handleValue)
 
 		local function cleanup()
-			self._maid[sub] = nil
+			self._maid[sub :: any] = nil
 			conn:Disconnect()
 			sub:Complete()
 			maid:Destroy()
 		end
-		self._maid[sub] = cleanup
+		self._maid[sub :: any] = cleanup
 		return cleanup
-	end)
+	end) :: any
 end
 
 --[=[
@@ -150,7 +171,7 @@ end
 	@param key TKey
 	@return TValue
 ]=]
-function ObservableMap:Get(key)
+function ObservableMap.Get<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey): TValue?
 	assert(key ~= nil, "Bad key")
 
 	return self._map[key]
@@ -161,7 +182,7 @@ end
 	@param key TKey
 	@return boolean
 ]=]
-function ObservableMap:ContainsKey(key)
+function ObservableMap.ContainsKey<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey): boolean
 	assert(key ~= nil, "Bad key")
 
 	return self._map[key] ~= nil
@@ -171,7 +192,7 @@ end
 	Gets the count of items in the set
 	@return number
 ]=]
-function ObservableMap:GetCount()
+function ObservableMap.GetCount<TKey, TValue>(self: ObservableMap<TKey, TValue>): number
 	return self._countValue.Value or 0
 end
 
@@ -182,7 +203,7 @@ ObservableMap.__len = ObservableMap.GetCount
 
 	@return Observable<number>
 ]=]
-function ObservableMap:ObserveCount()
+function ObservableMap.ObserveCount<TKey, TValue>(self: ObservableMap<TKey, TValue>): Observable.Observable<number>
 	return self._countValue:Observe()
 end
 
@@ -192,14 +213,17 @@ end
 	@param key TKey
 	@return Observable<Brio<TValue>>
 ]=]
-function ObservableMap:ObserveAtKeyBrio(key)
+function ObservableMap.ObserveAtKeyBrio<TKey, TValue>(
+	self: ObservableMap<TKey, TValue>,
+	key: TKey
+): Observable.Observable<Brio.Brio<TValue>>
 	assert(key ~= nil, "Bad key")
 
 	return self:ObserveAtKey(key):Pipe({
 		RxBrioUtils.switchToBrio(function(value)
 			return value ~= nil
-		end);
-	})
+		end),
+	}) :: any
 end
 
 --[=[
@@ -208,12 +232,12 @@ end
 	@param key TKey
 	@return Observable<TValue?>
 ]=]
-function ObservableMap:ObserveAtKey(key)
+function ObservableMap.ObserveAtKey<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey): Observable.Observable<TValue?>
 	assert(key ~= nil, "Bad key")
 
 	return self._keySubTable:Observe(key, function(sub)
-		sub:Fire(self._map[key])
-	end)
+		sub:Fire(self._map[key] :: any)
+	end) :: any
 end
 
 --[=[
@@ -232,25 +256,23 @@ ObservableMap.ObserveValueForKey = ObservableMap.ObserveAtKey
 	@param value TValue?
 	@return callback -- Call to remove the value if it was added
 ]=]
-function ObservableMap:Set(key, value)
+function ObservableMap.Set<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey, value: TValue?): () -> ()
 	assert(key ~= nil, "Bad key")
 
-	local oldValue = self._map[key]
+	local oldValue: TValue? = self._map[key]
 	if oldValue == value then
 		-- no removal since we never added. this is a tad messy.
-		return function()
-
-		end
+		return function() end
 	end
 
-	self._map[key] = value
+	self._map[key] = value :: any
 
-	if oldValue == nil then
-		self._countValue.Value = self._countValue.Value + 1
-		self.KeyAdded:Fire(key, value)
-	elseif value == nil then
+	if value == nil then
 		self._countValue.Value = self._countValue.Value - 1
 		self.KeyRemoved:Fire(key)
+	elseif oldValue == nil then
+		self._countValue.Value = self._countValue.Value + 1
+		self.KeyAdded:Fire(key, value)
 	end
 
 	self.KeyValueChanged:Fire(key, value, oldValue)
@@ -259,7 +281,7 @@ function ObservableMap:Set(key, value)
 	return self:_getRemovalCallback(key, value)
 end
 
-function ObservableMap:_getRemovalCallback(key, value)
+function ObservableMap._getRemovalCallback<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey, value: TValue?): () -> ()
 	return function()
 		if not self.Destroy then
 			return
@@ -275,7 +297,7 @@ end
 	Removes the item from the map if it exists.
 	@param key TKey
 ]=]
-function ObservableMap:Remove(key)
+function ObservableMap.Remove<TKey, TValue>(self: ObservableMap<TKey, TValue>, key: TKey): ()
 	assert(key ~= nil, "Bad key")
 
 	self:Set(key, nil)
@@ -285,9 +307,9 @@ end
 	Gets a list of all values.
 	@return { TValue }
 ]=]
-function ObservableMap:GetValueList()
+function ObservableMap.GetValueList<TKey, TValue>(self: ObservableMap<TKey, TValue>): { TValue }
 	local list = table.create(self._countValue.Value)
-	for _, value in pairs(self._map) do
+	for _, value in self._map do
 		table.insert(list, value)
 	end
 	return list
@@ -297,9 +319,9 @@ end
 	Gets a list of all keys.
 	@return { TKey }
 ]=]
-function ObservableMap:GetKeyList()
+function ObservableMap.GetKeyList<TKey, TValue>(self: ObservableMap<TKey, TValue>): { TKey }
 	local list = table.create(self._countValue.Value)
-	for key, _ in pairs(self._map) do
+	for key, _ in self._map do
 		table.insert(list, key)
 	end
 	return list
@@ -309,13 +331,13 @@ end
 	Observes the list of all keys.
 	@return Observable<{ TKey }>
 ]=]
-function ObservableMap:ObserveKeyList()
+function ObservableMap.ObserveKeyList<TKey, TValue>(self: ObservableMap<TKey, TValue>): Observable.Observable<{ TKey }>
 	return Observable.new(function(sub)
 		local topMaid = Maid.new()
 
 		-- TODO: maybe don't allocate as much here?
 		local keyList = table.create(self._countValue.Value)
-		for key, _ in pairs(self._map) do
+		for key, _ in self._map do
 			table.insert(keyList, key)
 		end
 
@@ -335,15 +357,15 @@ function ObservableMap:ObserveKeyList()
 		sub:Fire(table.clone(keyList))
 
 		return topMaid
-	end)
+	end) :: any
 end
 
 --[=[
 	Cleans up the ObservableMap and sets the metatable to nil.
 ]=]
-function ObservableMap:Destroy()
+function ObservableMap.Destroy<TKey, TValue>(self: ObservableMap<TKey, TValue>)
 	self._maid:DoCleaning()
-	setmetatable(self, nil)
+	setmetatable(self :: any, nil)
 end
 
 return ObservableMap

package/src/Shared/ObservableMapList.lua

@@ -299,12 +299,12 @@ end
 	@param index number
 	@return ObservableList<TValue>
 ]=]
-function ObservableMapList:GetListOfValuesAtListIndex(index)
+function ObservableMapList:GetListOfValuesAtListIndex(index: number)
 	assert(type(index) == "number", "Bad index")
 
 	local list = table.create(self._observableMapOfLists:GetCount())
 
-	for _, observableList in pairs(self._observableMapOfLists:GetValueList()) do
+	for _, observableList in self._observableMapOfLists:GetValueList() do
 		local value = observableList:Get(index)
 		if value ~= nil then
 			table.insert(list, value)