@quenty/brio 14.29.1 → 14.30.0

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.1",
+  "version": "14.30.0",
   "description": "Brios wrap an object and either are alive or dead",
   "keywords": [
     "Roblox",
@@ -32,7 +32,7 @@
     "@quenty/loader": "10.11.0",
     "@quenty/maid": "3.9.0",
     "@quenty/nevermore-test-runner": "1.4.0",
-    "@quenty/rx": "13.28.1",
+    "@quenty/rx": "13.28.2",
     "@quenty/signal": "7.13.0",
     "@quenty/steputils": "3.6.3",
     "@quenty/table": "3.9.2",
@@ -41,5 +41,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6801a02bc7e7de951df4b9f65c0efc27b642db70"
+  "gitHead": "f4a374a0a294ee8900aa5cb68ab138b0acf3e0ae"
 }

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