@quenty/observablecollection 12.19.4-canary.544.d46888c.0 → 12.19.4

package/CHANGELOG.md

@@ -3,7 +3,7 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [12.19.4-canary.544.d46888c.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@12.19.3...@quenty/observablecollection@12.19.4-canary.544.d46888c.0) (2025-03-28)
+## [12.19.4](https://github.com/Quenty/NevermoreEngine/compare/@quenty/observablecollection@12.19.3...@quenty/observablecollection@12.19.4) (2025-03-31)
 
 **Note:** Version bump only for package @quenty/observablecollection
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/observablecollection",
-  "version": "12.19.4-canary.544.d46888c.0",
+  "version": "12.19.4",
   "description": "A set of observable collections, such as sets, maps, sorted lists, and more.",
   "keywords": [
     "Roblox",
@@ -27,24 +27,24 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "10.8.0",
-    "@quenty/brio": "14.16.2-canary.544.d46888c.0",
-    "@quenty/ducktype": "5.8.1",
-    "@quenty/loader": "10.8.0",
-    "@quenty/maid": "3.4.0",
-    "@quenty/promise": "10.10.1",
-    "@quenty/rx": "13.16.2-canary.544.d46888c.0",
-    "@quenty/signal": "7.10.0",
-    "@quenty/steputils": "3.5.3",
-    "@quenty/symbol": "3.4.0",
-    "@quenty/table": "3.7.1",
-    "@quenty/valueobject": "13.16.2-canary.544.d46888c.0"
+    "@quenty/baseobject": "^10.8.0",
+    "@quenty/brio": "^14.16.2",
+    "@quenty/ducktype": "^5.8.1",
+    "@quenty/loader": "^10.8.0",
+    "@quenty/maid": "^3.4.0",
+    "@quenty/promise": "^10.10.1",
+    "@quenty/rx": "^13.16.2",
+    "@quenty/signal": "^7.10.0",
+    "@quenty/steputils": "^3.5.3",
+    "@quenty/symbol": "^3.4.0",
+    "@quenty/table": "^3.7.1",
+    "@quenty/valueobject": "^13.16.2"
   },
   "devDependencies": {
-    "@quenty/blend": "12.17.2-canary.544.d46888c.0"
+    "@quenty/blend": "^12.17.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d46888c8ff66a7c7df276948146279c58cc05a18"
+  "gitHead": "af926ec08f523833f37d22477c72dca034219823"
 }

package/src/Shared/ObservableCountingMap.spec.lua

@@ -4,38 +4,35 @@
 
 local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
 
-local Jest = require("Jest")
 local ObservableCountingMap = require("ObservableCountingMap")
 
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
-
-describe("ObservableCountingMap.new()", function()
-	local observableCountingMap = ObservableCountingMap.new()
-
-	it("should return 0 for unset values", function()
-		expect(observableCountingMap:Get("a")).toEqual(0)
-		expect(observableCountingMap:GetTotalKeyCount()).toEqual(0)
-	end)
-
-	it("should allow you to add to a value", function()
-		expect(observableCountingMap:Get("a")).toEqual(0)
-		expect(observableCountingMap:GetTotalKeyCount()).toEqual(0)
-		observableCountingMap:Add("a", 5)
-		expect(observableCountingMap:Get("a")).toEqual(5)
-		expect(observableCountingMap:GetTotalKeyCount()).toEqual(1)
-	end)
-
-	it("should allow you to add to a value that is already defined", function()
-		expect(observableCountingMap:Get("a")).toEqual(5)
-		expect(observableCountingMap:GetTotalKeyCount()).toEqual(1)
-		observableCountingMap:Add("a", 5)
-		expect(observableCountingMap:Get("a")).toEqual(10)
-		expect(observableCountingMap:GetTotalKeyCount()).toEqual(1)
-	end)
-
-	it("should clean up", function()
-		observableCountingMap:Destroy()
+return function()
+	describe("ObservableCountingMap.new()", function()
+		local observableCountingMap = ObservableCountingMap.new()
+
+		it("should return 0 for unset values", function()
+			expect(observableCountingMap:Get("a")).to.equal(0)
+			expect(observableCountingMap:GetTotalKeyCount()).to.equal(0)
+		end)
+
+		it("should allow you to add to a value", function()
+			expect(observableCountingMap:Get("a")).to.equal(0)
+			expect(observableCountingMap:GetTotalKeyCount()).to.equal(0)
+			observableCountingMap:Add("a", 5)
+			expect(observableCountingMap:Get("a")).to.equal(5)
+			expect(observableCountingMap:GetTotalKeyCount()).to.equal(1)
+		end)
+
+		it("should allow you to add to a value that is already defined", function()
+			expect(observableCountingMap:Get("a")).to.equal(5)
+			expect(observableCountingMap:GetTotalKeyCount()).to.equal(1)
+			observableCountingMap:Add("a", 5)
+			expect(observableCountingMap:Get("a")).to.equal(10)
+			expect(observableCountingMap:GetTotalKeyCount()).to.equal(1)
+		end)
+
+		it("should clean up", function()
+			observableCountingMap:Destroy()
+		end)
 	end)
-end)
+end

package/src/Shared/ObservableList.spec.lua

@@ -4,130 +4,127 @@
 
 local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
 
-local Jest = require("Jest")
 local ObservableList = require("ObservableList")
 
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
+return function()
+	describe("ObservableList.new()", function()
+		local observableList = ObservableList.new()
 
-describe("ObservableList.new()", function()
-	local observableList = ObservableList.new()
-
-	it("should return nil for unset values", function()
-		expect(observableList:Get(1)).toEqual(nil)
-	end)
+		it("should return nil for unset values", function()
+			expect(observableList:Get(1)).to.equal(nil)
+		end)
 
-	it("should allow inserting an value", function()
-		expect(observableList:GetCount()).toEqual(0)
+		it("should allow inserting an value", function()
+			expect(observableList:GetCount()).to.equal(0)
 
-		observableList:Add("a")
+			observableList:Add("a")
 
-		expect(observableList:Get(1)).toEqual("a")
-		expect(observableList:GetCount()).toEqual(1)
-	end)
+			expect(observableList:Get(1)).to.equal("a")
+			expect(observableList:GetCount()).to.equal(1)
+		end)
 
-	it("should allow negative queries", function()
-		expect(observableList:Get(-1)).toEqual("a")
-		expect(observableList:Get(-2)).toEqual(nil)
-	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)).toEqual(nil)
-		observableList:Add(false)
-		expect(observableList:Get(2)).toEqual(false)
-	end)
+		it("should allow false as a value", function()
+			expect(observableList:Get(2)).to.equal(nil)
+			observableList:Add(false)
+			expect(observableList:Get(2)).to.equal(false)
+		end)
 
-	it("should allow negative queries after false", function()
-		expect(observableList:Get(1)).toEqual("a")
-		expect(observableList:Get(2)).toEqual(false)
+		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)).toEqual(false)
-		expect(observableList:Get(-2)).toEqual("a")
-	end)
-
-	it("should fire off events for a specific key", function()
-		local seen = {}
-		local sub = observableList:ObserveIndex(1):Subscribe(function(value)
-			table.insert(seen, value)
+			expect(observableList:Get(-1)).to.equal(false)
+			expect(observableList:Get(-2)).to.equal("a")
 		end)
-		observableList:InsertAt("c", 1)
 
-		sub:Destroy()
+		it("should fire off events for a specific key", function()
+			local seen = {}
+			local sub = observableList:ObserveIndex(1):Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+			observableList:InsertAt("c", 1)
 
-		expect(#seen).toEqual(2)
-		expect(seen[1]).toEqual(1)
-		expect(seen[2]).toEqual(2)
-	end)
+			sub:Destroy()
 
-	it("should fire off events for all keys", function()
-		local seen = {}
-		local sub = observableList:ObserveItemsBrio():Subscribe(function(value)
-			table.insert(seen, value)
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal(1)
+			expect(seen[2]).to.equal(2)
 		end)
-		observableList:Add("a")
 
-		expect(#seen).toEqual(4)
-		expect(seen[4]:GetValue()).toEqual("a")
-		expect(seen[4]:IsDead()).toEqual(false)
+		it("should fire off events for all keys", function()
+			local seen = {}
+			local sub = observableList:ObserveItemsBrio():Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+			observableList:Add("a")
 
-		sub:Destroy()
+			expect(#seen).to.equal(4)
+			expect(seen[4]:GetValue()).to.equal("a")
+			expect(seen[4]:IsDead()).to.equal(false)
 
-		expect(#seen).toEqual(4)
-		expect(seen[4]:IsDead()).toEqual(true)
-	end)
+			sub:Destroy()
 
-	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)
+			expect(#seen).to.equal(4)
+			expect(seen[4]:IsDead()).to.equal(true)
 		end)
 
-		local originalList = observableList:GetList()
-		expect(originalList[1]).toEqual("c")
+		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)
 
-		observableList:InsertAt("dragon", 1)
+			local originalList = observableList:GetList()
+			expect(originalList[1]).to.equal("c")
 
-		sub:Destroy()
+			observableList:InsertAt("dragon", 1)
 
-		expect(#seen).toEqual(2)
-		expect(seen[1]).toEqual("c")
-		expect(seen[2]).toEqual("dragon")
-	end)
+			sub:Destroy()
 
-	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)
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal("c")
+			expect(seen[2]).to.equal("dragon")
 		end)
 
-		local originalList = observableList:GetList()
-		expect(originalList[#originalList]).toEqual("a")
+		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)
 
-		observableList:Add("fire")
+			local originalList = observableList:GetList()
+			expect(originalList[#originalList]).to.equal("a")
 
-		sub:Destroy()
+			observableList:Add("fire")
 
-		expect(#seen).toEqual(2)
-		expect(seen[1]).toEqual("a")
-		expect(seen[2]).toEqual("fire")
-	end)
+			sub:Destroy()
 
-	it("should fire off events on removal", function()
-		local seen = {}
-		local sub = observableList:ObserveIndex(2):Subscribe(function(value)
-			table.insert(seen, value)
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal("a")
+			expect(seen[2]).to.equal("fire")
 		end)
-		observableList:RemoveAt(1)
 
-		sub:Destroy()
+		it("should fire off events on removal", function()
+			local seen = {}
+			local sub = observableList:ObserveIndex(2):Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+			observableList:RemoveAt(1)
 
-		expect(#seen).toEqual(2)
-		expect(seen[1]).toEqual(2)
-		expect(seen[2]).toEqual(1)
-	end)
+			sub:Destroy()
+
+			expect(#seen).to.equal(2)
+			expect(seen[1]).to.equal(2)
+			expect(seen[2]).to.equal(1)
+		end)
 
-	it("should clean up", function()
-		observableList:Destroy()
+		it("should clean up", function()
+			observableList:Destroy()
+		end)
 	end)
-end)
+end

package/src/Shared/ObservableMap.spec.lua

@@ -4,74 +4,71 @@
 
 local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
 
-local Jest = require("Jest")
 local ObservableMap = require("ObservableMap")
 
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
+return function()
+	describe("ObservableMap.new()", function()
+		local observableMap = ObservableMap.new()
 
-describe("ObservableMap.new()", function()
-	local observableMap = ObservableMap.new()
-
-	it("should return nil for unset values", function()
-		expect(observableMap:Get("a")).toEqual(nil)
-	end)
+		it("should return nil for unset values", function()
+			expect(observableMap:Get("a")).to.equal(nil)
+		end)
 
-	it("should allow setting a value", function()
-		expect(observableMap:GetCount()).toEqual(0)
+		it("should allow setting a value", function()
+			expect(observableMap:GetCount()).to.equal(0)
 
-		observableMap:Set("a", "Hello World")
+			observableMap:Set("a", "Hello World")
 
-		expect(observableMap:Get("a")).toEqual("Hello World")
-		expect(observableMap:GetCount()).toEqual(1)
-	end)
-
-	it("should overwrite values", function()
-		expect(observableMap:Get("a")).toEqual("Hello World")
+			expect(observableMap:Get("a")).to.equal("Hello World")
+			expect(observableMap:GetCount()).to.equal(1)
+		end)
 
-		observableMap:Set("a", "Hello World 2")
+		it("should overwrite values", function()
+			expect(observableMap:Get("a")).to.equal("Hello World")
 
-		expect(observableMap:Get("a")).toEqual("Hello World 2")
-	end)
+			observableMap:Set("a", "Hello World 2")
 
-	it("should allow false as a key", function()
-		expect(observableMap:Get(false)).toEqual(nil)
-		observableMap:Set(false, "Hello")
-		expect(observableMap:Get(false)).toEqual("Hello")
-	end)
+			expect(observableMap:Get("a")).to.equal("Hello World 2")
+		end)
 
-	it("should fire off events for a specific key", function()
-		local seen = {}
-		local sub = observableMap:ObserveValueForKey("c"):Subscribe(function(value)
-			table.insert(seen, value)
+		it("should allow false as a key", function()
+			expect(observableMap:Get(false)).to.equal(nil)
+			observableMap:Set(false, "Hello")
+			expect(observableMap:Get(false)).to.equal("Hello")
 		end)
-		observableMap:Set("c", "Hello")
 
-		sub:Destroy()
+		it("should fire off events for a specific key", function()
+			local seen = {}
+			local sub = observableMap:ObserveValueForKey("c"):Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+			observableMap:Set("c", "Hello")
 
-		expect(#seen).toEqual(1)
-		expect(seen[1]).toEqual("Hello")
-	end)
+			sub:Destroy()
 
-	it("should fire off events for all keys", function()
-		local seen = {}
-		local sub = observableMap:ObserveValuesBrio():Subscribe(function(value)
-			table.insert(seen, value)
+			expect(#seen).to.equal(1)
+			expect(seen[1]).to.equal("Hello")
 		end)
-		observableMap:Set("d", "Hello")
 
-		expect(#seen).toEqual(4)
-		expect(seen[4]:GetValue()).toEqual("Hello")
-		expect(seen[4]:IsDead()).toEqual(false)
+		it("should fire off events for all keys", function()
+			local seen = {}
+			local sub = observableMap:ObserveValuesBrio():Subscribe(function(value)
+				table.insert(seen, value)
+			end)
+			observableMap:Set("d", "Hello")
 
-		sub:Destroy()
+			expect(#seen).to.equal(4)
+			expect(seen[4]:GetValue()).to.equal("Hello")
+			expect(seen[4]:IsDead()).to.equal(false)
 
-		expect(#seen).toEqual(4)
-		expect(seen[4]:IsDead()).toEqual(true)
-	end)
+			sub:Destroy()
 
-	it("should clean up", function()
-		observableMap:Destroy()
+			expect(#seen).to.equal(4)
+			expect(seen[4]:IsDead()).to.equal(true)
+		end)
+
+		it("should clean up", function()
+			observableMap:Destroy()
+		end)
 	end)
-end)
+end

package/src/Shared/ObservableMapList.spec.lua

@@ -4,24 +4,21 @@
 
 local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
 
-local Jest = require("Jest")
 local ObservableMapList = require("ObservableMapList")
 
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
+return function()
+	describe("ObservableMapList.new()", function()
+		local observableMapList = ObservableMapList.new()
 
-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 return nil for unset values", function()
-		expect(observableMapList:GetAtListIndex("dragon", 1)).toEqual(nil)
+		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)
-
-	it("should allow additions", function()
-		observableMapList:Add("hello", "dragon")
-		expect(observableMapList:GetAtListIndex("dragon", 1)).toEqual("hello")
-		expect(observableMapList:GetAtListIndex("dragon", -1)).toEqual("hello")
-		expect(observableMapList:GetAtListIndex("fire", 1)).toEqual(nil)
-	end)
-end)
+end

package/src/Shared/SortedList/ObservableSortedList.spec.lua

@@ -4,56 +4,53 @@
 
 local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
 
-local Jest = require("Jest")
 local ObservableSortedList = require("ObservableSortedList")
 local Rx = require("Rx")
 local StepUtils = require("StepUtils")
 
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
+return function()
+	describe("ObservableSortedList.new()", function()
+		local observableSortedList = ObservableSortedList.new()
 
-describe("ObservableSortedList.new()", function()
-	local observableSortedList = ObservableSortedList.new()
+		it("should return nil for unset values", function()
+			expect(observableSortedList:Get(1)).to.equal(nil)
+		end)
 
-	it("should return nil for unset values", function()
-		expect(observableSortedList:Get(1)).toEqual(nil)
-	end)
-
-	it("should allow inserting an value", function()
-		expect(observableSortedList:GetCount()).toEqual(0)
+		it("should allow inserting an value", function()
+			expect(observableSortedList:GetCount()).to.equal(0)
 
-		observableSortedList:Add("b", Rx.of("b"))
+			observableSortedList:Add("b", Rx.of("b"))
 
-		StepUtils.deferWait()
+			StepUtils.deferWait()
 
-		expect(observableSortedList:Get(1)).toEqual("b")
-		expect(observableSortedList:GetCount()).toEqual(1)
-	end)
+			expect(observableSortedList:Get(1)).to.equal("b")
+			expect(observableSortedList:GetCount()).to.equal(1)
+		end)
 
-	it("should sort the items", function()
-		expect(observableSortedList:GetCount()).toEqual(1)
+		it("should sort the items", function()
+			expect(observableSortedList:GetCount()).to.equal(1)
 
-		observableSortedList:Add("a", Rx.of("a"))
+			observableSortedList:Add("a", Rx.of("a"))
 
-		StepUtils.deferWait()
+			StepUtils.deferWait()
 
-		expect(observableSortedList:Get(1)).toEqual("a")
-		expect(observableSortedList:Get(2)).toEqual("b")
-		expect(observableSortedList:GetCount()).toEqual(2)
-	end)
+			expect(observableSortedList:Get(1)).to.equal("a")
+			expect(observableSortedList:Get(2)).to.equal("b")
+			expect(observableSortedList:GetCount()).to.equal(2)
+		end)
 
-	it("should add in order if number is the same", function()
-		observableSortedList = ObservableSortedList.new()
-		observableSortedList:Add("a", Rx.of(0))
-		observableSortedList:Add("b", Rx.of(0))
-		observableSortedList:Add("c", Rx.of(0))
+		it("should add in order if number is the same", function()
+			observableSortedList = ObservableSortedList.new()
+			observableSortedList:Add("a", Rx.of(0))
+			observableSortedList:Add("b", Rx.of(0))
+			observableSortedList:Add("c", Rx.of(0))
 
-		StepUtils.deferWait()
+			StepUtils.deferWait()
 
-		expect(observableSortedList:Get(1)).toEqual("a")
-		expect(observableSortedList:Get(2)).toEqual("b")
-		expect(observableSortedList:Get(3)).toEqual("c")
-		expect(observableSortedList:GetCount()).toEqual(3)
+			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(3)
+		end)
 	end)
-end)
+end