@quenty/observablecollection 5.14.0 → 5.15.0

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.15.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@5.14.0...@quenty/observablecollection@5.15.0) (2023-05-08)
+
+
+### Bug Fixes
+
+* Fix removal firing events to fire correctly ([10f98c3](https://github.com/Quenty/NevermoreEngine/commit/10f98c329e7bab203ffc056d1ffb0c2c715392a8))
+
+
+### Features
+
+* Add ObservableSet:ObserveContains(item) ([df5beba](https://github.com/Quenty/NevermoreEngine/commit/df5beba6b196933653365719c26e6ed9fa21d4cc))
+* Add ObservableSortedList:ObserveAtIndex(indexToObserve) and ObservableSortedList:FindFirstKey(content) ([4d9f4d8](https://github.com/Quenty/NevermoreEngine/commit/4d9f4d8d34eafa0899157e4960ea87c9c812cf48))
+
+
+
+
+
 # [5.14.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@5.13.0...@quenty/observablecollection@5.14.0) (2023-04-20)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/observablecollection",
-  "version": "5.14.0",
+  "version": "5.15.0",
   "description": "A set of observable collections, such as sets, maps, sorted lists, and more.",
   "keywords": [
     "Roblox",
@@ -27,17 +27,17 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/brio": "^8.11.0",
+    "@quenty/brio": "^8.12.0",
     "@quenty/loader": "^6.2.1",
     "@quenty/maid": "^2.5.0",
     "@quenty/promise": "^6.5.0",
     "@quenty/rx": "^7.10.0",
     "@quenty/signal": "^2.3.0",
     "@quenty/symbol": "^2.2.0",
-    "@quenty/valuebaseutils": "^7.12.0"
+    "@quenty/valuebaseutils": "^7.13.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "15d1274fffdaef706f849fd5dca2f14364c1264e"
+  "gitHead": "2ad8cea7dd3ad79a39afd7d7b785b489b90553fd"
 }

package/src/Shared/ObservableCountingMap.lua

@@ -214,7 +214,7 @@ function ObservableCountingMap:Set(key, amount)
 	end
 
 	if current < amount then
-		self:Remove(amount - current)
+		self:Add(-(amount - current))
 		return
 	elseif current == amount then
 		return
@@ -237,29 +237,50 @@ function ObservableCountingMap:Add(key, amount)
 
 	if amount == 0 then
 		return
-	elseif amount < 0 then
-		self:Remove(key, -amount)
-		return
 	end
 
-	if not self._map[key] then
+	if self._map[key] then
+		local newValue = self._map[key] + amount
+		if newValue == 0 then
+			-- Remove item
+			self._map[key] = nil
+
+			-- Fire events
+			self._totalKeyCountValue.Value = self._totalKeyCountValue.Value - 1
+
+			if self.Destroy then
+				self.KeyRemoved:Fire(key)
+			end
+
+			if self.Destroy then
+				self.KeyChanged:Fire(key, 0)
+			end
+		else
+			-- Update item
+			self._map[key] = newValue
+			self.KeyChanged:Fire(key, newValue)
+		end
+	else
+		-- Add item
 		self._map[key] = amount
+
+		-- Fire events
 		self._totalKeyCountValue.Value = self._totalKeyCountValue.Value + 1
 
 		if self.Destroy then
 			self.KeyAdded:Fire(key)
 		end
-	else
-		local newValue = self._map[key] + amount
-		self._map[key] = newValue
-		self.KeyChanged:Fire(key, newValue)
+
+		if self.Destroy then
+			self.KeyChanged:Fire(key, amount)
+		end
 	end
 
 	local removed = false
 	return function()
 		if self.Destroy and not removed then
 			removed = true
-			self:RemoveCount(key, amount)
+			self:Add(key, -amount)
 		end
 	end
 end
@@ -270,40 +291,12 @@ end
 	@param amount number?
 	@return callback
 ]=]
-function ObservableCountingMap:RemoveCount(key, amount)
+function ObservableCountingMap:Remove(key, amount)
 	assert(key ~= nil, "Bad key")
 	assert(type(amount) == "number" or amount == nil, "Bad amount")
 	amount = amount or 1
 
-	if amount == 0 then
-		return
-	elseif amount < 0 then
-		self:Add(key, -amount)
-		return
-	end
-
-	local current = self._map[key]
-	if not current then
-		return
-	end
-
-	local newValue = current - amount
-	if newValue > 0 then
-		self._map[key] = newValue
-		self.KeyChanged:Fire(key, newValue)
-	else
-		self._map[key] = nil
-
-		self._totalKeyCountValue.Value = self._totalKeyCountValue.Value - 1
-
-		if self.Destroy then
-			self.KeyRemoved:Fire(key)
-		end
-
-		if self.Destroy then
-			self.KeyChanged:Fire(key, 0)
-		end
-	end
+	self:Add(key, -amount)
 end
 
 --[=[

package/src/Shared/ObservableSet.lua

@@ -10,6 +10,7 @@ local Observable = require("Observable")
 local Maid = require("Maid")
 local Brio = require("Brio")
 local RxValueBaseUtils = require("RxValueBaseUtils")
+local ObservableSubscriptionTable = require("ObservableSubscriptionTable")
 
 local ObservableSet = {}
 ObservableSet.ClassName = "ObservableSet"
@@ -25,6 +26,9 @@ function ObservableSet.new()
 	self._maid = Maid.new()
 	self._set = {}
 
+	self._containsObservables = ObservableSubscriptionTable.new()
+	self._maid:GiveTask(self._containsObservables)
+
 	self._countValue = Instance.new("IntValue")
 	self._countValue.Value = 0
 	self._maid:GiveTask(self._countValue)
@@ -99,6 +103,39 @@ function ObservableSet:ObserveItemsBrio()
 	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 item T
+	@return Observable<boolean>
+]=]
+function ObservableSet:ObserveContains(item)
+	assert(item ~= nil, "Bad item")
+
+	return Observable.new(function(sub)
+		local maid = Maid.new()
+
+		if self._set[item] then
+			sub:Fire(true)
+		else
+			sub:Fire(false)
+		end
+
+		maid:GiveTask(self._containsObservables:Observe(item):Subscribe(function(doesContain)
+			sub:Fire(doesContain)
+		end))
+
+		self._maid[sub] = maid
+		maid:GiveTask(function()
+			self._maid[sub] = nil
+			sub:Complete()
+		end)
+
+		return maid
+	end)
+end
+
 --[=[
 	Returns whether the set contains the item
 	@param item T
@@ -135,9 +172,12 @@ function ObservableSet:Add(item)
 	assert(item ~= nil, "Bad item")
 
 	if not self._set[item] then
-		self._countValue.Value = self._countValue.Value + 1
 		self._set[item] = true
+
+		-- Fire events
+		self._countValue.Value = self._countValue.Value + 1
 		self.ItemAdded:Fire(item)
+		self._containsObservables:Fire(item, true)
 	end
 
 	return function()
@@ -155,12 +195,14 @@ function ObservableSet:Remove(item)
 	assert(item ~= nil, "Bad item")
 
 	if self._set[item] then
-		self._countValue.Value = self._countValue.Value - 1
 		self._set[item] = nil
 
+		-- Fire in reverse order
+		self._containsObservables:Fire(item, false)
 		if self.Destroy then
 			self.ItemRemoved:Fire(item)
 		end
+		self._countValue.Value = self._countValue.Value - 1
 	end
 end
 

package/src/Shared/ObservableSortedList.lua

@@ -20,10 +20,11 @@ local Maid = require("Maid")
 local Brio = require("Brio")
 local RxValueBaseUtils = require("RxValueBaseUtils")
 local Symbol = require("Symbol")
+local ObservableSubscriptionTable = require("ObservableSubscriptionTable")
 
--- Higher numbers last
+-- Higher numbers last. Using <= ensures insertion at end on ties.
 local function defaultCompare(a, b)
-	return a < b
+	return a <= b
 end
 
 local ObservableSortedList = {}
@@ -42,6 +43,12 @@ function ObservableSortedList.new(compare)
 
 	self._keyList = {} -- { [number]: Symbol } -- immutable
 
+	self._indexObservers = ObservableSubscriptionTable.new()
+	self._maid:GiveTask(self._indexObservers)
+
+	self._contentIndexObservers = ObservableSubscriptionTable.new()
+	self._maid:GiveTask(self._contentIndexObservers)
+
 	self._sortValue = {} -- { [Symbol]: number }
 	self._contents = {} -- { [Symbol]: T }
 	self._indexes = {} -- { [Symbol]: number }
@@ -123,6 +130,22 @@ function ObservableSortedList:ObserveItemsBrio()
 	end)
 end
 
+--[=[
+	Gets the first key for a given symbol
+
+	@param content T
+	@return Symbol
+]=]
+function ObservableSortedList:FindFirstKey(content)
+	for key, item  in pairs(self._contents) do
+		if item == content then
+			return key
+		end
+	end
+
+	return nil
+end
+
 --[=[
 	Observes the index as it changes, until the entry at the existing
 	index is removed.
@@ -141,6 +164,34 @@ function ObservableSortedList:ObserveIndex(indexToObserve)
 	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 ObservableSortedList:ObserveAtIndex(indexToObserve)
+	assert(type(indexToObserve) == "number", "Bad 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
+		})
+end
+
 --[=[
 	Observes the index as it changes, until the entry at the existing
 	key is removed.
@@ -410,6 +461,7 @@ function ObservableSortedList:_removeItemByKey(key, item)
 	local itemRemoved = {
 		key = key;
 		item = item;
+		previousIndex = index;
 	}
 
 	-- TODO: Defer item removed as a changed event?
@@ -453,14 +505,26 @@ function ObservableSortedList:_queueDeferredChange()
 
 			self._countValue.Value = self._countValue.Value + snapshot.countChange
 
-			if self.Destroy then
-				-- Fire off last adds
-				for _, lastAdded in pairs(snapshot.itemsAdded) do
-					self.ItemAdded:Fire(lastAdded.item, lastAdded.newIndex, lastAdded.key)
+			-- Fire off last adds
+			for _, lastAdded in pairs(snapshot.itemsAdded) do
+				if not self.ItemAdded.Destroy then
+					break
 				end
+				self.ItemAdded:Fire(lastAdded.item, lastAdded.newIndex, lastAdded.key)
+
+				-- Item adds are included in indexChanges.
+			end
 
-				for _, lastRemoved in pairs(snapshot.itemsRemoved) do
-					self.ItemRemoved:Fire(lastRemoved.item, lastRemoved.key)
+			for _, lastRemoved in pairs(snapshot.itemsRemoved) do
+				if not self.ItemRemoved.Destroy then
+					break
+				end
+
+				self.ItemRemoved:Fire(lastRemoved.item, lastRemoved.key)
+
+				-- Fire only if we aren't handled by an index change.
+				if self._keyList[lastRemoved.previousIndex] == nil then
+					self._indexObservers:Fire(lastRemoved.previousIndex, nil)
 				end
 			end
 
@@ -471,6 +535,8 @@ function ObservableSortedList:_queueDeferredChange()
 					if subs then
 						self:_fireSubs(subs, lastChange.newIndex)
 					end
+
+					self._indexObservers:Fire(lastChange.newIndex, self._contents[lastChange.key])
 				end
 			end
 		end)