@quenty/observablecollection 5.24.0 → 5.25.0

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.
 
+# [5.25.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@5.24.0...@quenty/observablecollection@5.25.0) (2023-09-04)
+
+
+### Features
+
+* Add ObservableMapList.new() and fix unit tests ([84e16ed](https://github.com/Quenty/NevermoreEngine/commit/84e16ed86af9bbc1ad19486f0298a9f7f3484b3e))
+
+
+
+
+
 # [5.24.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@5.23.0...@quenty/observablecollection@5.24.0) (2023-08-23)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/observablecollection",
-  "version": "5.24.0",
+  "version": "5.25.0",
   "description": "A set of observable collections, such as sets, maps, sorted lists, and more.",
   "keywords": [
     "Roblox",
@@ -28,17 +28,18 @@
   ],
   "dependencies": {
     "@quenty/baseobject": "^6.3.0",
-    "@quenty/brio": "^8.17.0",
+    "@quenty/brio": "^8.18.0",
     "@quenty/loader": "^6.3.0",
     "@quenty/maid": "^2.6.0",
     "@quenty/promise": "^6.8.0",
     "@quenty/rx": "^7.15.0",
     "@quenty/signal": "^2.4.0",
+    "@quenty/steputils": "^3.3.0",
     "@quenty/symbol": "^2.2.0",
-    "@quenty/valueobject": "^7.22.0"
+    "@quenty/valueobject": "^7.23.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3b7e47e2180964b6b0b156d07814810e063ef7ed"
+  "gitHead": "fa0826fa54fabecb242d7c0753e2e7644ba02e11"
 }

package/src/Shared/ObservableCountingMap.lua

@@ -311,7 +311,7 @@ end
 	Gets a list of all keys.
 	@return { T }
 ]=]
-function ObservableCountingMap:GetKeysList()
+function ObservableCountingMap:GetKeyList()
 	local list = {}
 	for key, _ in pairs(self._map) do
 		table.insert(list, key)

package/src/Shared/ObservableList.lua

@@ -5,13 +5,15 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local Signal = require("Signal")
-local Observable = require("Observable")
-local Maid = require("Maid")
 local Brio = require("Brio")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local ObservableSubscriptionTable = require("ObservableSubscriptionTable")
+local Rx = require("Rx")
+local RxBrioUtils = require("RxBrioUtils")
+local Signal = require("Signal")
 local Symbol = require("Symbol")
 local ValueObject = require("ValueObject")
-local Rx = require("Rx")
 
 local ObservableList = {}
 ObservableList.ClassName = "ObservableList"
@@ -30,7 +32,11 @@ function ObservableList.new()
 	self._contents = {} -- { [Symbol]: T }
 	self._indexes = {} -- { [Symbol]: number }
 
-	self._keyObservables = {} -- { [Symbol]: { Subscription } }
+	self._indexObservers = ObservableSubscriptionTable.new()
+	self._maid:GiveTask(self._indexObservers)
+
+	self._keyIndexObservables = ObservableSubscriptionTable.new()
+	self._maid:GiveTask(self._keyIndexObservables)
 
 	self._countValue = ValueObject.new(0, "number")
 	self._maid:GiveTask(self._countValue)
@@ -134,12 +140,43 @@ function ObservableList:ObserveIndex(indexToObserve)
 
 	local key = self._keyList[indexToObserve]
 	if not key then
-		error(("No entry at index %q, cannot observe changes"):format(indexToObserve))
+		error(string.format("No entry at index %q, cannot observe changes", indexToObserve))
 	end
 
 	return self:ObserveIndexByKey(key)
 end
 
+--[=[
+	Observes the current value at a given index. This can be useful for observing
+	the first entry, or matching stuff up to a given slot.
+
+	@param indexToObserve number
+	@return Observable<T?>
+]=]
+function ObservableList:ObserveAtIndex(indexToObserve)
+	assert(type(indexToObserve) == "number", "Bad indexToObserve")
+
+	return self._indexObservers:Observe(indexToObserve, function(sub)
+		sub:Fire(self:Get(indexToObserve))
+	end)
+end
+
+--[=[
+	Observes the current value at a given index. This can be useful for observing
+	the first entry, or matching stuff up to a given slot.
+
+	@param indexToObserve number
+	@return Observable<Brio<T>>
+]=]
+function ObservableList:ObserveAtIndexBrio(indexToObserve)
+	assert(type(indexToObserve) == "number", "Bad indexToObserve")
+
+	return self:ObserveAtIndex(indexToObserve):Pipe({
+		RxBrioUtils.toBrio();
+		RxBrioUtils.onlyLastBrioSurvives();
+	})
+end
+
 --[=[
 	Removes the first instance found in contents
 
@@ -176,35 +213,8 @@ end
 function ObservableList:ObserveIndexByKey(key)
 	assert(type(key) == "userdata", "Bad key")
 
-	return Observable.new(function(sub)
-		local currentIndex = self._indexes[key]
-		if not currentIndex then
-			sub:Complete()
-			return
-		end
-
-		local maid = Maid.new()
-		self._keyObservables[key] = self._keyObservables[key] or {}
-		table.insert(self._keyObservables[key], sub)
-
-		sub:Fire(currentIndex)
-
-		maid:GiveTask(function()
-			local list = self._keyObservables[key]
-			if not list then
-				return
-			end
-
-			local index = table.find(list, sub)
-			if index then
-				table.remove(list, index)
-				if #list == 0 then
-					self._keyObservables[key] = nil
-				end
-			end
-		end)
-
-		return maid
+	return self._keyIndexObservables:Observe(key, function(sub)
+		sub:Fire(self:GetIndexByKey(key))
 	end)
 end
 
@@ -256,6 +266,8 @@ end
 function ObservableList:Get(index)
 	assert(type(index) == "number", "Bad index")
 
+	index = self:_toPositiveIndex(index)
+
 	local key = self._keyList[index]
 	if not key then
 		return nil
@@ -289,17 +301,14 @@ function ObservableList:InsertAt(item, index)
 		self._indexes[nextKey] = i + 1
 		self._keyList[i + 1] = nextKey
 
-		local subs = self._keyObservables[nextKey]
-		if subs then
-			table.insert(changed, {
-				key = nextKey;
-				newIndex = i + 1;
-				subs = subs;
-			})
-		end
+		table.insert(changed, {
+			key = nextKey;
+			newIndex = i + 1;
+		})
 	end
 
 	self._keyList[index] = key
+	local listLength = #self._keyList
 
 	-- Fire off count
 	self._countValue.Value = self._countValue.Value + 1
@@ -307,23 +316,17 @@ function ObservableList:InsertAt(item, index)
 	-- Fire off add
 	self.ItemAdded:Fire(item, index, key)
 
-	-- Fire off the index change on the value
-	do
-		local subs = self._keyObservables[key]
-		if subs then
-			table.insert(changed, {
-				key = key;
-				newIndex = index;
-				subs = subs;
-			})
-		end
-	end
 
+	-- Fire off the index change on the value
+	self._keyIndexObservables:Fire(key, index)
+	self._indexObservers:Fire(index, item)
+	self._indexObservers:Fire(self:_toNegativeIndex(listLength, index), item)
 
-	-- Fire off index change on each key list (if the data isn't stale)
 	for _, data in pairs(changed) do
 		if self._indexes[data.key] == data.newIndex then
-			self:_fireSubs(data.subs, data.newIndex)
+			self._indexObservers:Fire(data.newIndex, self._contents[data.key])
+			self._indexObservers:Fire(self:_toNegativeIndex(listLength, index), self._contents[data.key])
+			self._keyIndexObservables:Fire(data.key, data.newIndex)
 		end
 	end
 
@@ -368,8 +371,6 @@ function ObservableList:RemoveByKey(key)
 		return nil
 	end
 
-	local observableSubs = self._keyObservables[key]
-	self._keyObservables[key] = nil
 	self._indexes[key] = nil
 	self._contents[key] = nil
 
@@ -382,16 +383,13 @@ function ObservableList:RemoveByKey(key)
 		self._indexes[nextKey] = i
 		self._keyList[i] = nextKey
 
-		local subs = self._keyObservables[nextKey]
-		if subs then
-			table.insert(changed, {
-				key = nextKey;
-				newIndex = i;
-				subs = subs;
-			})
-		end
+		table.insert(changed, {
+			key = nextKey;
+			newIndex = i;
+		})
 	end
 	self._keyList[n] = nil
+	local listLength = #self._keyList
 
 	-- Fire off that count changed
 	self._countValue.Value = self._countValue.Value - 1
@@ -401,39 +399,25 @@ function ObservableList:RemoveByKey(key)
 	end
 
 	-- Fire off the index change on the value
-	if observableSubs then
-		self:_completeSubs(observableSubs)
+	self._keyIndexObservables:Complete(key)
+	self._indexObservers:Fire(listLength, nil)
+
+	if listLength == 0 then
+		self._indexObservers:Fire(-1, nil)
 	end
 
 	-- Fire off index change on each key list (if the data isn't stale)
 	for _, data in pairs(changed) do
 		if self._indexes[data.key] == data.newIndex then
-			self:_fireSubs(data.subs, data.newIndex)
+			self._indexObservers:Fire(data.newIndex, self._contents[data.key])
+			self._indexObservers:Fire(self:_toNegativeIndex(listLength, index), self._contents[data.key])
+			self._keyIndexObservables:Fire(data.key, data.newIndex)
 		end
 	end
 
 	return item
 end
 
-function ObservableList:_fireSubs(list, index)
-	for _, sub in pairs(list) do
-		if sub:IsPending() then
-			task.spawn(function()
-				sub:Fire(index)
-			end)
-		end
-	end
-end
-
-function ObservableList:_completeSubs(list)
-	for _, sub in pairs(list) do
-		if sub:IsPending() then
-			sub:Fire(nil)
-			sub:Complete()
-		end
-	end
-end
-
 --[=[
 	Gets a list of all entries.
 	@return { T }
@@ -446,6 +430,20 @@ function ObservableList:GetList()
 	return list
 end
 
+function ObservableList:_toPositiveIndex(index)
+	if index > 0 then
+		return index
+	elseif index < 0 then
+		return #self._keyList + index + 1
+	else
+		error(string.format("[ObservableList._toPositiveIndex] - Bad index %d", index))
+	end
+end
+
+function ObservableList:_toNegativeIndex(listLength, index)
+	return -listLength + index - 1
+end
+
 --[=[
 	Cleans up the ObservableList and sets the metatable to nil.
 ]=]

package/src/Shared/ObservableList.spec.lua

@@ -23,6 +23,10 @@ return function()
 			expect(observableList:GetCount()).to.equal(1)
 		end)
 
+		it("should allow negative queries", function()
+			expect(observableList:Get(-1)).to.equal("a")
+			expect(observableList:Get(-2)).to.equal(nil)
+		end)
 
 		it("should allow false as a value", function()
 			expect(observableList:Get(2)).to.equal(nil)
@@ -30,6 +34,14 @@ return function()
 			expect(observableList:Get(2)).to.equal(false)
 		end)
 
+		it("should allow negative queries after false", function()
+			expect(observableList:Get(1)).to.equal("a")
+			expect(observableList:Get(2)).to.equal(false)
+
+			expect(observableList:Get(-1)).to.equal(false)
+			expect(observableList:Get(-2)).to.equal("a")
+		end)
+
 		it("should fire off events for a specific key", function()
 			local seen = {}
 			local sub = observableList:ObserveIndex(1):Subscribe(function(value)
@@ -61,6 +73,42 @@ return function()
 			expect(seen[4]:IsDead()).to.equal(true)
 		end)
 
+		it("it should be able to observe a specific key", function()
+			local seen = {}
+			local sub = observableList:ObserveAtIndex(1):Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+
+			local originalList = observableList:GetList()
+			expect(originalList[1]).to.equal("c")
+
+			observableList:InsertAt("dragon", 1)
+
+			sub:Destroy()
+
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal("c")
+			expect(seen[2]).to.equal("dragon")
+		end)
+
+		it("it should be able to observe a specific negative key", function()
+			local seen = {}
+			local sub = observableList:ObserveAtIndex(-1):Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+
+			local originalList = observableList:GetList()
+			expect(originalList[#originalList]).to.equal("a")
+
+			observableList:Add("fire")
+
+			sub:Destroy()
+
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal("a")
+			expect(seen[2]).to.equal("fire")
+		end)
+
 		it("should fire off events on removal", function()
 			local seen = {}
 			local sub = observableList:ObserveIndex(2):Subscribe(function(value)

package/src/Shared/ObservableMap.lua

@@ -11,6 +11,7 @@ local Observable = require("Observable")
 local ObservableSubscriptionTable = require("ObservableSubscriptionTable")
 local Signal = require("Signal")
 local ValueObject = require("ValueObject")
+local RxBrioUtils = require("RxBrioUtils")
 
 local ObservableMap = {}
 ObservableMap.ClassName = "ObservableMap"
@@ -170,6 +171,7 @@ end
 
 --[=[
 	Observes the count of the set
+
 	@return Observable<number>
 ]=]
 function ObservableMap:ObserveCount()
@@ -177,11 +179,29 @@ function ObservableMap:ObserveCount()
 end
 
 --[=[
-	Observes the value for the given slot
+	Observes the value for the given key.
+
+	@param key TKey
+	@return Observable<Brio<TValue>>
+]=]
+function ObservableMap:ObserveAtKeyBrio(key)
+	assert(key ~= nil, "Bad key")
+
+	return self:ObserveAtKey(key):Pipe({
+		RxBrioUtils.toBrio();
+		RxBrioUtils.where(function(value)
+			return value ~= nil
+		end)
+	})
+end
+
+--[=[
+	Observes the value for the given key.
+
 	@param key TKey
 	@return Observable<TValue?>
 ]=]
-function ObservableMap:ObserveValueForKey(key)
+function ObservableMap:ObserveAtKey(key)
 	assert(key ~= nil, "Bad key")
 
 	return self._keySubTable:Observe(key, function(sub)
@@ -189,6 +209,16 @@ function ObservableMap:ObserveValueForKey(key)
 	end)
 end
 
+--[=[
+	Observes the value for the given key. Alias for [ObservableMap.ObserveAtKey].
+
+	@function ObserveValueForKey
+	@param key TKey
+	@return Observable<TValue?>
+	@within ObservableMap
+]=]
+ObservableMap.ObserveValueForKey = ObservableMap.ObserveAtKey
+
 --[=[
 	Adds the item to the set if it does not exists.
 	@param key TKey

package/src/Shared/ObservableMapList.lua

@@ -0,0 +1,303 @@
+--[=[
+	Holds a map of lists. This is good for list-based
+
+	@class ObservableMapList
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Maid = require("Maid")
+local Observable = require("Observable")
+local ObservableList = require("ObservableList")
+local ObservableMap = require("ObservableMap")
+local Rx = require("Rx")
+local RxBrioUtils = require("RxBrioUtils")
+
+local ObservableMapList = {}
+ObservableMapList.ClassName = "ObservableMapList"
+ObservableMapList.__index = ObservableMapList
+
+--[=[
+	Constructs a new ObservableMapList
+	@return ObservableMapList<TKey, TValue>
+]=]
+function ObservableMapList.new()
+	local self = setmetatable({}, ObservableMapList)
+
+	self._maid = Maid.new()
+	self._observableMapOfLists = self._maid:Add(ObservableMap.new())
+
+	return self
+end
+
+--[=[
+	Adds an entry with a dynamic key. This is great for caching things
+	that need to be looked up by key.
+
+	:::tip
+	If `observeKey` emits nil then the value will be excluded from the list.
+	:::
+
+	@param entry TValue
+	@param observeKey Observable<TKey>
+	@return MaidTask -- Cleanup object that will remove the entry
+]=]
+function ObservableMapList:Push(observeKey, entry)
+	assert(observeKey ~= nil, "Bad observeKey")
+	assert(entry ~= nil, "Bad entry")
+
+	if not Observable.isObservable(observeKey) then
+		observeKey = Rx.of(observeKey)
+	end
+
+	local maid = Maid.new()
+
+	local lastKey = nil
+	local function removeLastEntry()
+		if lastKey ~= nil then
+			self:_removeFromList(lastKey, entry)
+		end
+		lastKey = nil
+	end
+
+	maid:GiveTask(observeKey:Subscribe(function(key)
+		removeLastEntry()
+
+		if key ~= nil then
+			self:_addToList(key, entry)
+		end
+
+		lastKey = key
+	end))
+
+	maid:GiveTask(removeLastEntry)
+
+	-- Ensure self-cleanup when map cleans up
+	self._maid[maid] = maid
+	maid:GiveTask(function()
+		self._maid[maid] = nil
+	end)
+
+	return maid
+end
+
+--[=[
+	Gets how many lists exist
+	@return number
+]=]
+function ObservableMapList:GetListCount()
+	return self._observableMapOfLists:GetCount()
+end
+
+--[=[
+	Observes how many lists exist
+	@return Observable<number>
+]=]
+function ObservableMapList:ObserveListCount()
+	return self._observableMapOfLists:ObserveCount()
+end
+
+--[=[
+	Gets the current value at the list index
+
+	@param key TKey
+	@param index number
+	@return Observable<TValue?>
+]=]
+function ObservableMapList:GetAtListIndex(key, index)
+	assert(key ~= nil, "Bad key")
+	assert(type(index) == "number", "Bad index")
+
+	local list = self._observableMapOfLists:Get(key)
+	if list then
+		return list:Get(index)
+	else
+		return nil
+	end
+end
+
+--[=[
+	Observes the current value at the index
+
+	@param key TKey
+	@param index number
+	@return Observable<TValue?>
+]=]
+function ObservableMapList:ObserveAtListIndex(key, index)
+	assert(key ~= nil, "Bad key")
+	assert(type(index) == "number", "Bad index")
+
+	return self._observableMapOfLists:ObserveAtKey(key):Pipe({
+		Rx.switchMap(function(list)
+			if list then
+				return list:ObserveAtIndex(index)
+			else
+				return Rx.of(nil)
+			end
+		end);
+	})
+end
+
+--[=[
+	Gets a list of all keys
+
+	@return { TKey }
+]=]
+function ObservableMapList:GetKeyList()
+	return self._observableMapOfLists:GetKeyList()
+end
+
+
+--[=[
+	Observes all keys in the map
+	@return Observable<Brio<TKey>>
+]=]
+function ObservableMapList:ObserveKeysBrio()
+	return self._observableMapOfLists:ObserveKeysBrio()
+end
+
+--[=[
+	Observes the current value at the index
+
+	@param key TKey
+	@param index number
+	@return Observable<Brio<TValue>>
+]=]
+function ObservableMapList:ObserveAtListIndexBrio(key, index)
+	assert(key ~= nil, "Bad key")
+	assert(type(index) == "number", "Bad index")
+
+	return self._observableMapOfLists:ObserveAtKeyBrio(key):Pipe({
+		RxBrioUtils.switchMapBrio(function(list)
+			return list:ObserveAtIndexBrio(-1)
+		end);
+		RxBrioUtils.toBrio();
+		RxBrioUtils.where(function(value)
+			return value ~= nil
+		end)
+	})
+end
+
+--[=[
+	Observes all items at the given key
+
+	@param key TKey
+	@return Observable<Brio<TValue>>
+]=]
+function ObservableMapList:ObserveItemsForKeyBrio(key)
+	assert(key ~= nil, "Bad key")
+
+	return self._observableMapOfLists:ObserveAtKeyBrio(key):Pipe({
+		RxBrioUtils.switchMapBrio(function(list)
+			if list then
+				return list:ObserveItemsBrio()
+			else
+				return Rx.EMPTY
+			end
+		end);
+	})
+end
+
+--[=[
+	Gets a list for a given key.
+
+	@param key TKey
+	@return { TValue }
+]=]
+function ObservableMapList:GetListForKey(key)
+	assert(key ~= nil, "Bad key")
+
+	local observableList = self:GetListForKey(key)
+	if not observableList then
+		return {}
+	end
+
+	return observableList:GetList()
+end
+
+--[=[
+	Gets the observable list for the given key
+	@param key TKey
+	@return ObservableList<TValue>
+]=]
+function ObservableMapList:GetListForKey(key)
+	assert(key ~= nil, "Bad key")
+
+	return self._observableMapOfLists:Get(key)
+end
+
+function ObservableMapList:ObserveListBrio(key)
+	assert(key ~= nil, "Bad key")
+
+	return self._observableMapOfLists:ObserveAtKey(key)
+end
+
+function ObservableMapList:ObserveCountForKey(key)
+	assert(key ~= nil, "Bad key")
+
+	return self:ObserveListBrio(key):Pipe({
+		RxBrioUtils.switchMapBrio(function(observableList)
+			return observableList:ObserveCount()
+		end);
+		RxBrioUtils.emitOnDeath(0);
+	})
+end
+
+function ObservableMapList:_addToList(key, entry)
+	local list = self:_getOrCreateList(key)
+	list:Add(entry)
+end
+
+function ObservableMapList:_removeFromList(key, entry)
+	local list = self._observableMapOfLists:Get(key)
+	if not list then
+		return
+	end
+
+	-- This happens when we're cleaning up sometimes
+	if not list.Destroy then
+		return
+	end
+
+	if list:Contains(entry) then
+		list:Remove(entry)
+
+		if list:GetCount() == 0 then
+			self:_removeList(key)
+		end
+	end
+end
+
+function ObservableMapList:_removeList(key)
+	local list = self._observableLists[key]
+	if list then
+		self._observableLists[key] = nil
+		self._maid[list] = nil
+	end
+end
+
+function ObservableMapList:_getOrCreateList(key)
+	local existing = self._observableMapOfLists:Get(key)
+	if existing then
+		return existing
+	end
+
+	local maid = Maid.new()
+	local list = maid:Add(ObservableList.new(nil))
+
+	self._observableMapOfLists:Set(key, list)
+	self._maid[list] = maid
+
+	return list
+end
+
+--[=[
+	Cleans up the ObservableMapList and sets the metatable to nil.
+]=]
+function ObservableMapList:Destroy()
+	self._maid:DoCleaning()
+	setmetatable(self, nil)
+end
+
+
+return ObservableMapList

package/src/Shared/ObservableMapList.spec.lua

@@ -0,0 +1,24 @@
+--[[
+	@class ObservableMapList.spec.lua
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)
+
+local ObservableMapList = require("ObservableMapList")
+
+return function()
+	describe("ObservableMapList.new()", function()
+		local observableMapList = ObservableMapList.new()
+
+		it("should return nil for unset values", function()
+			expect(observableMapList:GetAtListIndex("dragon", 1)).to.equal(nil)
+		end)
+
+		it("should allow additions", function()
+			observableMapList:Add("hello", "dragon")
+			expect(observableMapList:GetAtListIndex("dragon", 1)).to.equal("hello")
+			expect(observableMapList:GetAtListIndex("dragon", -1)).to.equal("hello")
+			expect(observableMapList:GetAtListIndex("fire", 1)).to.equal(nil)
+		end)
+	end)
+end

package/src/Shared/ObservableMapSet.lua

@@ -14,6 +14,7 @@ local Signal = require("Signal")
 local Brio = require("Brio")
 local RxBrioUtils = require("RxBrioUtils")
 local ValueObject = require("ValueObject")
+local Rx = require("Rx")
 
 local ObservableMapSet = {}
 ObservableMapSet.ClassName = "ObservableMapSet"
@@ -57,15 +58,28 @@ end
 	Adds an entry with a dynamic key. This is great for caching things
 	that need to be looked up by key.
 
+	:::tip
+	If `observeKey` emits nil then the value will be excluded from the map.
+	:::
+
 	@param entry TValue
-	@param observeKey Observable<TKey>
+	@param observeKey Observable<TKey> | TKey
+	@return MaidTask -- Cleanup object that will remove the entry
 ]=]
-function ObservableMapSet:Add(entry, observeKey)
+
+function ObservableMapSet:Push(observeKey, entry)
+	assert(observeKey ~= nil, "Bad observeKey")
+	assert(entry ~= nil, "Bad entry")
+
+	if not Observable.isObservable(observeKey) then
+		observeKey = Rx.of(observeKey)
+	end
+
 	local maid = Maid.new()
 
 	local lastKey = nil
 	local function removeLastEntry()
-		if lastKey then
+		if lastKey ~= nil then
 			self:_removeFromObservableSet(lastKey, entry)
 		end
 		lastKey = nil
@@ -74,14 +88,13 @@ function ObservableMapSet:Add(entry, observeKey)
 	maid:GiveTask(observeKey:Subscribe(function(key)
 		removeLastEntry()
 
-		if key then
+		if key ~= nil then
 			self:_addToObservableSet(key, entry)
 		end
 
 		lastKey = key
 	end))
 
-
 	maid:GiveTask(removeLastEntry)
 
 	-- Ensure self-cleanup when map cleans up
@@ -93,6 +106,30 @@ function ObservableMapSet:Add(entry, observeKey)
 	return maid
 end
 
+--[=[
+	Adds an entry with a dynamic key. This is great for caching things
+	that need to be looked up by key.
+
+	This code is legacy code since our argument order isn't intuitive
+
+	:::tip
+	If `observeKey` emits nil then the value will be excluded from the map.
+	:::
+
+	@param entry TValue
+	@param observeKey Observable<TKey> | TKey
+	@return MaidTask -- Cleanup object that will remove the entry
+]=]
+function ObservableMapSet:Add(entry, observeKey)
+	assert(Observable.isObservable(observeKey), "Bad observeKey")
+	assert(entry ~= nil, "Bad entry")
+
+	warn(string.format("[ObservableMapSet.Add] - This API call will swap observable key order eventually. Use ObservableMapSet.Push for now to suppress this warning.\n%s",
+		debug.traceback()))
+
+	return self:Push(observeKey, entry)
+end
+
 --[=[
 	Gets how many sets exist
 	@return number

package/src/Shared/ObservableSortedList.lua

@@ -199,19 +199,9 @@ function ObservableSortedList:ObserveAtIndex(indexToObserve)
 
 	return self._indexObservers:Observe(indexToObserve)
 		:Pipe({
-			function(source)
-				return Observable.new(function(sub)
-					local key = self._keyList[indexToObserve]
-
-					if key then
-						sub:Fire(self._contents[key]) -- Look up the content
-					else
-						sub:Fire(nil)
-					end
-
-					return source:Subscribe(sub:GetFireFailComplete())
-				end)
-			end
+			Rx.start(function()
+				return self:Get(indexToObserve)
+			end);
 		})
 end
 

package/src/Shared/ObservableSortedList.spec.lua

@@ -6,6 +6,7 @@ local require = require(game:GetService("ServerScriptService"):FindFirstChild("L
 
 local ObservableSortedList = require("ObservableSortedList")
 local Rx = require("Rx")
+local StepUtils = require("StepUtils")
 
 return function()
 	describe("ObservableSortedList.new()", function()
@@ -20,6 +21,8 @@ return function()
 
 			observableSortedList:Add("b", Rx.of("b"))
 
+			StepUtils.deferWait()
+
 			expect(observableSortedList:Get(1)).to.equal("b")
 			expect(observableSortedList:GetCount()).to.equal(1)
 		end)
@@ -29,6 +32,8 @@ return function()
 
 			observableSortedList:Add("a", Rx.of("a"))
 
+			StepUtils.deferWait()
+
 			expect(observableSortedList:Get(1)).to.equal("a")
 			expect(observableSortedList:Get(2)).to.equal("b")
 			expect(observableSortedList:GetCount()).to.equal(2)
@@ -40,10 +45,12 @@ return function()
 			observableSortedList:Add("b", Rx.of(0))
 			observableSortedList:Add("c", Rx.of(0))
 
+			StepUtils.deferWait()
+
 			expect(observableSortedList:Get(1)).to.equal("a")
 			expect(observableSortedList:Get(2)).to.equal("b")
 			expect(observableSortedList:Get(3)).to.equal("c")
-			expect(observableSortedList:GetCount()).to.equal(1)
+			expect(observableSortedList:GetCount()).to.equal(3)
 		end)
 	end)
 end