@quenty/brio 14.29.2 → 14.30.1

package/deploy.nevermore.json

@@ -0,0 +1,10 @@
+{
+  "targets": {
+    "test": {
+      "universeId": 9716264427,
+      "placeId": 122679562100430,
+      "project": "test/default.project.json",
+      "scriptTemplate": "test/scripts/Server/ServerMain.server.lua"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/brio",
-  "version": "14.29.2",
+  "version": "14.30.1",
   "description": "Brios wrap an object and either are alive or dead",
   "keywords": [
     "Roblox",
@@ -32,8 +32,8 @@
     "@quenty/loader": "10.11.0",
     "@quenty/maid": "3.9.0",
     "@quenty/nevermore-test-runner": "1.4.0",
-    "@quenty/rx": "13.28.2",
-    "@quenty/signal": "7.13.0",
+    "@quenty/rx": "13.28.3",
+    "@quenty/signal": "7.13.1",
     "@quenty/steputils": "3.6.3",
     "@quenty/table": "3.9.2",
     "@quentystudios/jest-lua": "3.10.0-quenty.2"
@@ -41,5 +41,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7672b52f13af6a10df1b189d19d6e2404b5b3e55"
+  "gitHead": "598b2b62b36bdcbdbbd56f7db10c399831cc6eba"
 }

package/src/Shared/Brio.lua

@@ -21,7 +21,7 @@
 
 	Brios are useful for downstream events where you want to emit a resource. Typically
 	brios should be killed when their source is killed. Brios are intended to be merged
-	with downstream brios so create a chain of reliable resources.
+	with downstream brios to create a chain of reliable resources.
 
 	```lua
 	local brio = Brio.new("a", "b")
@@ -103,7 +103,7 @@ function Brio.new<T...>(...: T...): Brio<T...>
 end
 
 --[=[
-	Constructs a new brio that will cleanup afer the set amount of time
+	Constructs a new brio that will cleanup after the set amount of time
 
 	@since 3.6.0
 	@param time number
@@ -153,7 +153,7 @@ function Brio.GetDiedSignal<T...>(self: Brio<T...>): Signal.Signal<T...>
 end
 
 --[=[
-	Returns true is the brio is dead.
+	Returns true if the brio is dead.
 
 	```lua
 	local brio = Brio.new("a", "b")
@@ -287,7 +287,7 @@ function Brio.Destroy<T...>(self: Brio<T...>)
 end
 
 --[=[
-	Alias for Destroy.
+	Alias for [Brio.Destroy].
 	@method Kill
 	@within Brio
 ]=]

package/src/Shared/RxBrioUtils.lua

@@ -471,7 +471,7 @@ end
 	3. All resources are invalidated
 	4. We still wanted to be able to use most of the resources
 
-	With this method we are able to do this, as we'll re-emit a table with all resoruces
+	With this method we are able to do this, as we'll re-emit a table with all resources
 	except the invalidated one.
 
 	@since 3.6.0

package/src/Shared/RxBrioUtils.spec.lua

@@ -10,6 +10,7 @@ local require = (require :: any)(
 local Brio = require("Brio")
 local Jest = require("Jest")
 local Observable = require("Observable")
+local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
 
 local describe = Jest.Globals.describe
@@ -34,8 +35,8 @@ end)
 describe("RxBrioUtils.combineLatest({ value = Observable(Brio(5)) })", function()
 	it("should execute immediately", function()
 		local observe = RxBrioUtils.combineLatest({
-			value = Observable.new(function(sub)
-				sub:Fire(Brio.new(5))
+			value = Observable.new(function(innerSub)
+				innerSub:Fire(Brio.new(5))
 			end),
 			otherValue = 25,
 		})
@@ -123,3 +124,444 @@ describe("RxBrioUtils.flatCombineLatest", function()
 		sub:Destroy()
 	end)
 end)
+
+describe("RxBrioUtils.switchToBrio", function()
+	it("should wrap a plain value in a brio", function()
+		local result
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fire(42)
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+			end)
+
+		expect(result).never.toBeNil()
+		expect(Brio.isBrio(result)).toEqual(true)
+		expect(result:IsDead()).toEqual(false)
+		expect(result:GetValue()).toEqual(42)
+
+		sub:Destroy()
+	end)
+
+	it("should wrap multiple plain values, packing them into a brio", function()
+		local result
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fire("a", "b")
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+			end)
+
+		expect(result).never.toBeNil()
+		expect(Brio.isBrio(result)).toEqual(true)
+		expect(result:IsDead()).toEqual(false)
+
+		local a, b = result:GetValue()
+		expect(a).toEqual("a")
+		expect(b).toEqual("b")
+
+		sub:Destroy()
+	end)
+
+	it("should clone an input brio instead of forwarding it directly", function()
+		local inputBrio = Brio.new(99)
+		local result
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fire(inputBrio)
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+			end)
+
+		expect(result).never.toBeNil()
+		expect(Brio.isBrio(result)).toEqual(true)
+		expect(result:GetValue()).toEqual(99)
+		-- Should be a clone, not the same object
+		expect(result).never.toEqual(inputBrio)
+
+		sub:Destroy()
+		inputBrio:Kill()
+	end)
+
+	it("should kill the previous brio when a new value is emitted", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		doFire(1)
+		doFire(2)
+
+		expect(#results).toEqual(2)
+		expect(results[1]:IsDead()).toEqual(true)
+		expect(results[2]:IsDead()).toEqual(false)
+		expect(results[2]:GetValue()).toEqual(2)
+
+		sub:Destroy()
+	end)
+
+	it("should kill the previous brio even when the new value is filtered by predicate", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(function(value)
+					return value ~= "skip"
+				end),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		doFire("keep")
+		expect(#results).toEqual(1)
+		expect(results[1]:IsDead()).toEqual(false)
+
+		doFire("skip") -- predicate rejects, but should still kill previous
+		expect(#results).toEqual(1)
+		expect(results[1]:IsDead()).toEqual(true)
+
+		sub:Destroy()
+	end)
+
+	it("should ignore dead brios from the source", function()
+		local deadBrio = Brio.new(10)
+		deadBrio:Kill()
+
+		local result
+		local fireCount = 0
+		local sub = Rx.of(deadBrio)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+				fireCount = fireCount + 1
+			end)
+
+		expect(fireCount).toEqual(0)
+		expect(result).toBeNil()
+
+		sub:Destroy()
+	end)
+
+	it("should kill clone when the source brio dies", function()
+		local inputBrio = Brio.new(5)
+		local result
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fire(inputBrio)
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+			end)
+
+		expect(result).never.toBeNil()
+		expect(result:IsDead()).toEqual(false)
+
+		inputBrio:Kill()
+		expect(result:IsDead()).toEqual(true)
+
+		sub:Destroy()
+	end)
+
+	it("should kill the last brio on unsubscribe", function()
+		local result
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fire(77)
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				result = brio
+			end)
+
+		expect(result).never.toBeNil()
+		expect(result:IsDead()).toEqual(false)
+
+		sub:Destroy()
+		expect(result:IsDead()).toEqual(true)
+	end)
+
+	it("should propagate failure from source", function()
+		local failed = false
+		local failMsg
+		local sub = Observable.new(function(innerSub)
+			innerSub:Fail("test error")
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function() end, function(err)
+				failed = true
+				failMsg = err
+			end)
+
+		expect(failed).toEqual(true)
+		expect(failMsg).toEqual("test error")
+
+		sub:Destroy()
+	end)
+
+	it("should propagate completion from source", function()
+		local completed = false
+		local sub = Observable.new(function(innerSub)
+			innerSub:Complete()
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function() end, function() end, function()
+				completed = true
+			end)
+
+		expect(completed).toEqual(true)
+
+		sub:Destroy()
+	end)
+
+	it("should apply predicate to plain values", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(function(value)
+					return value > 10
+				end),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		doFire(5)
+		expect(#results).toEqual(0)
+
+		doFire(15)
+		expect(#results).toEqual(1)
+		expect(results[1]:GetValue()).toEqual(15)
+
+		doFire(3)
+		expect(#results).toEqual(1)
+		expect(results[1]:IsDead()).toEqual(true)
+
+		sub:Destroy()
+	end)
+
+	it("should apply predicate to unwrapped brio values", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(function(value)
+					return value > 10
+				end),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		doFire(Brio.new(5))
+		expect(#results).toEqual(0)
+
+		doFire(Brio.new(20))
+		expect(#results).toEqual(1)
+		expect(results[1]:GetValue()).toEqual(20)
+
+		sub:Destroy()
+	end)
+
+	it("should handle rapid succession of emissions correctly", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		for i = 1, 100 do
+			doFire(i)
+		end
+
+		expect(#results).toEqual(100)
+
+		-- All but last should be dead
+		for i = 1, 99 do
+			expect(results[i]:IsDead()).toEqual(true)
+		end
+		expect(results[100]:IsDead()).toEqual(false)
+		expect(results[100]:GetValue()).toEqual(100)
+
+		sub:Destroy()
+	end)
+
+	it("should handle interleaved brio and plain value emissions", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		local inputBrio = Brio.new("from-brio")
+		doFire("plain")
+		doFire(inputBrio)
+		doFire("plain-again")
+
+		expect(#results).toEqual(3)
+		expect(results[1]:IsDead()).toEqual(true)
+		expect(results[2]:IsDead()).toEqual(true)
+		expect(results[3]:IsDead()).toEqual(false)
+		expect(results[3]:GetValue()).toEqual("plain-again")
+
+		sub:Destroy()
+	end)
+
+	it("should handle source brio dying while subscribed then new emission", function()
+		local doFire
+		local results = {}
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+			end)
+
+		local brio1 = Brio.new("first")
+		doFire(brio1)
+		expect(#results).toEqual(1)
+		expect(results[1]:IsDead()).toEqual(false)
+
+		-- Source brio dies externally
+		brio1:Kill()
+		expect(results[1]:IsDead()).toEqual(true)
+
+		-- New emission should still work
+		doFire("second")
+		expect(#results).toEqual(2)
+		expect(results[2]:IsDead()).toEqual(false)
+		expect(results[2]:GetValue()).toEqual("second")
+
+		sub:Destroy()
+	end)
+
+	it("should handle subscriber causing re-emission during fire", function()
+		-- Race condition: subscriber fires a new value during the callback
+		local doFire
+		local results = {}
+		local reEmitted = false
+
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(),
+			})
+			:Subscribe(function(brio)
+				table.insert(results, brio)
+
+				-- On first emission, synchronously emit another value
+				if not reEmitted then
+					reEmitted = true
+					doFire("re-emitted")
+				end
+			end)
+
+		doFire("initial")
+
+		expect(#results).toEqual(2)
+		-- The initial brio should be dead because re-emission killed it
+		expect(results[1]:IsDead()).toEqual(true)
+		-- The re-emitted brio should be alive
+		expect(results[2]:IsDead()).toEqual(false)
+		expect(results[2]:GetValue()).toEqual("re-emitted")
+
+		sub:Destroy()
+	end)
+
+	it("should not emit when predicate is provided and all values are rejected", function()
+		local doFire
+		local fireCount = 0
+
+		local sub = Observable.new(function(innerSub)
+			doFire = function(...)
+				innerSub:Fire(...)
+			end
+		end)
+			:Pipe({
+				RxBrioUtils.switchToBrio(function()
+					return false
+				end),
+			})
+			:Subscribe(function()
+				fireCount = fireCount + 1
+			end)
+
+		doFire(1)
+		doFire(2)
+		doFire(Brio.new(3))
+
+		expect(fireCount).toEqual(0)
+
+		sub:Destroy()
+	end)
+
+	it("should error with non-function predicate", function()
+		expect(function()
+			RxBrioUtils.switchToBrio("bad" :: any)
+		end).toThrow()
+	end)
+end)

package/test/default.project.json

@@ -0,0 +1,25 @@
+{
+  "name": "BrioTest",
+  "globIgnorePaths": [
+    "**/.package-lock.json",
+    "**/.pnpm",
+    "**/.pnpm-workspace-state-v1.json",
+    "**/.modules.yaml",
+    "**/.ignored",
+    "**/.ignored_*"
+  ],
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "$properties": {
+        "LoadStringEnabled": true
+      },
+      "brio": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    }
+  }
+}

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,13 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local root = ServerScriptService.brio
+local loader = root:FindFirstChild("LoaderUtils", true).Parent
+local require = require(loader).bootstrapGame(root)
+
+local NevermoreTestRunnerUtils = require("NevermoreTestRunnerUtils")
+if NevermoreTestRunnerUtils.runTestsIfNeededAsync(root) then
+	return
+end