@quenty/rx 13.11.1 → 13.12.0

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [13.12.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/rx@13.11.1...@quenty/rx@13.12.0) (2024-11-06)
+
+
+### Bug Fixes
+
+* Better stack traces ([247ce9b](https://github.com/Quenty/NevermoreEngine/commit/247ce9bd97753dec8c8fd6674f93cba2c7deca05))
+
+
+### Features
+
+* Add ObservableSubscriptionTable:Fail(key) ([0bb3fae](https://github.com/Quenty/NevermoreEngine/commit/0bb3faeaff104fe924122a7274a47539cd88350a))
+* Add unfinished observable sorted list ([c7e9817](https://github.com/Quenty/NevermoreEngine/commit/c7e9817f07c9431e5f7cdf1fa2e700d3b3277f60))
+* Optimize memory and perf with combineLatestDefer ([3bed556](https://github.com/Quenty/NevermoreEngine/commit/3bed55667c3c795402260575f57132404b906112))
+
+
+### Performance Improvements
+
+* Check canFire() and cache result ([34fc3d9](https://github.com/Quenty/NevermoreEngine/commit/34fc3d98ca9d1dbece1d1f82f40519e986cdd5fb))
+
+
+
+
+
 ## [13.11.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/rx@13.11.0...@quenty/rx@13.11.1) (2024-11-04)
 
 **Note:** Version bump only for package @quenty/rx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/rx",
-  "version": "13.11.1",
+  "version": "13.12.0",
   "description": "Quenty's reactive library for Roblox",
   "keywords": [
     "Roblox",
@@ -28,18 +28,18 @@
   ],
   "dependencies": {
     "@quenty/cancellabledelay": "^3.5.0",
-    "@quenty/canceltoken": "^11.8.1",
+    "@quenty/canceltoken": "^11.9.0",
     "@quenty/ducktype": "^5.7.1",
     "@quenty/loader": "^10.7.1",
     "@quenty/maid": "^3.4.0",
-    "@quenty/promise": "^10.7.1",
-    "@quenty/signal": "^7.8.1",
-    "@quenty/symbol": "^3.2.0",
+    "@quenty/promise": "^10.8.0",
+    "@quenty/signal": "^7.9.0",
+    "@quenty/symbol": "^3.3.0",
     "@quenty/table": "^3.6.0",
     "@quenty/throttle": "^10.8.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "01c43a0ddd3c5e0cb2d9027313dbfa9852eedef1"
+  "gitHead": "00e6f71716216dd6ecbc8505ad898a1ab7f72756"
 }

package/src/Shared/Observable.lua

@@ -107,7 +107,7 @@ function Observable.new(onSubscribe)
 	assert(type(onSubscribe) == "function", "Bad onSubscribe")
 
 	return setmetatable({
-		_source = if ENABLE_STACK_TRACING then debug.traceback() else nil;
+		_source = if ENABLE_STACK_TRACING then debug.traceback("Observable.new()", 2) else nil;
 		_onSubscribe = onSubscribe;
 	}, Observable)
 end

package/src/Shared/ObservableSubscriptionTable.lua

@@ -36,12 +36,28 @@ function ObservableSubscriptionTable:Fire(key, ...)
 	-- Make a copy so we don't have to worry about our last changing
 	for _, sub in pairs(table.clone(subs)) do
 		if sub:IsPending() then
+			-- TODO: Use connection here
 			task.spawn(sub.Fire, sub, ...)
 		end
 	end
 end
 
-function ObservableSubscriptionTable:Complete(key, ...)
+--[=[
+	Returns true if subscription exists
+
+	@param key TKey
+	@return boolean
+]=]
+function ObservableSubscriptionTable:HasSubscriptions(key)
+	return self._subMap[key] ~= nil
+end
+
+--[=[
+	Completes the subscription
+
+	@param key TKey
+]=]
+function ObservableSubscriptionTable:Complete(key)
 	local subs = self._subMap[key]
 	if not subs then
 		return
@@ -52,7 +68,28 @@ function ObservableSubscriptionTable:Complete(key, ...)
 
 	for _, sub in pairs(subsToComplete) do
 		if sub:IsPending() then
-			task.spawn(sub.Complete, sub, ...)
+			task.spawn(sub.Complete, sub)
+		end
+	end
+end
+
+--[=[
+	Fails the subscription
+
+	@param key TKey
+]=]
+function ObservableSubscriptionTable:Fail(key)
+	local subs = self._subMap[key]
+	if not subs then
+		return
+	end
+
+	local subsToFail = table.clone(subs)
+	self._subMap[key] = nil
+
+	for _, sub in pairs(subsToFail) do
+		if sub:IsPending() then
+			task.spawn(sub.Fail, sub)
 		end
 	end
 end
@@ -83,6 +120,7 @@ function ObservableSubscriptionTable:Observe(key, retrieveInitialValue)
 				return
 			end
 
+			-- TODO: Linked list
 			local index = table.find(current, sub)
 			if not index then
 				return
@@ -95,9 +133,7 @@ function ObservableSubscriptionTable:Observe(key, retrieveInitialValue)
 
 			-- Complete the subscription
 			if sub:IsPending() then
-				task.spawn(function()
-					sub:Complete()
-				end)
+				task.spawn(sub.Complete, sub)
 			end
 		end
 	end)
@@ -113,9 +149,7 @@ function ObservableSubscriptionTable:Destroy()
 
 		for _, sub in pairs(list) do
 			if sub:IsPending() then
-				task.spawn(function()
-					sub:Complete()
-				end)
+				task.spawn(sub.Complete, sub)
 			end
 		end
 	end

package/src/Shared/Rx.lua

@@ -19,6 +19,7 @@ local Symbol = require("Symbol")
 local ThrottledFunction = require("ThrottledFunction")
 local cancellableDelay = require("cancellableDelay")
 local CancelToken = require("CancelToken")
+local MaidTaskUtils = require("MaidTaskUtils")
 
 local UNSET_VALUE = Symbol.named("unsetValue")
 
@@ -138,6 +139,8 @@ end
 	@return Promise<T>
 ]=]
 function Rx.toPromise(observable, cancelToken)
+	assert(Observable.isObservable(observable), "Bad observable")
+
 	local maid = Maid.new()
 
 	local newCancelToken = CancelToken.new(function(cancel)
@@ -1008,7 +1011,7 @@ function Rx.switchAll()
 							if currentInside == observable then
 								sub:Fire(...)
 							else
-								warn(string.format("[Rx.switchAll] - Observable is still firing despite disconnect (%q)", observable._source))
+								warn(string.format("[Rx.switchAll] - Observable is still firing despite disconnect (%q)", tostring(observable._source)))
 							end
 						end, -- Merge each inner observable
 						function(...)
@@ -1446,12 +1449,14 @@ function Rx.combineLatest(observables)
 
 	return Observable.new(function(sub)
 		local pending = 0
+		local unset = 0
 		local latest = {}
 
 		-- Instead of caching this, use extra compute here
 		for key, value in pairs(observables) do
 			if Observable.isObservable(value) then
-				pending = pending + 1
+				pending += 1
+				unset += 1
 				latest[key] = UNSET_VALUE
 			else
 				latest[key] = value
@@ -1466,44 +1471,130 @@ function Rx.combineLatest(observables)
 
 		local maid = Maid.new()
 
-		local function fireIfAllSet()
-			for _, value in pairs(latest) do
-				if value == UNSET_VALUE then
-					return
-				end
+		local function failOnFirst(...)
+			pending -= 1
+			latest = nil
+			sub:Fail(...)
+		end
+
+		local function completeOnAllPendingDone()
+			pending -= 1
+			if pending == 0 then
+				latest = nil
+				sub:Complete()
+			end
+		end
+
+		for key, observer in pairs(observables) do
+			if not Observable.isObservable(observer) then
+				continue
+			end
+
+			maid:GiveTask(observer:Subscribe(
+				function(value)
+					if latest[key] == UNSET_VALUE then
+						unset -= 1
+					end
+
+					latest[key] = value
+
+					if unset == 0 then
+						sub:Fire(table.freeze(table.clone(latest)))
+					end
+				end,
+				failOnFirst,
+				completeOnAllPendingDone))
+		end
+
+		return maid
+	end)
+end
+
+--[=[
+	Equivalent of [Rx.combineLatest] and [Rx.throttleDefer] but avoids copying and emitting a new table
+	until after the frame ends. Helpful in scenarios where we write multiple times to a single value in a
+	frame, and we don't want to create a lot of work for the garbage collector.
+
+	@param observables { [TKey]: Observable<TEmitted> | TEmitted }
+	@return Observable<{ [TKey]: TEmitted }>
+]=]
+function Rx.combineLatestDefer(observables)
+	assert(type(observables) == "table", "Bad observables")
+
+	return Observable.new(function(sub)
+		local pending = 0
+		local unset = 0
+		local latest = {}
+
+		-- Instead of caching this, use extra compute here
+		for key, value in pairs(observables) do
+			if Observable.isObservable(value) then
+				pending += 1
+				unset += 1
+				latest[key] = UNSET_VALUE
+			else
+				latest[key] = value
 			end
+		end
 
-			sub:Fire(table.freeze(table.clone(latest)))
+		if pending == 0 then
+			sub:Fire(latest)
+			sub:Complete()
+			return
 		end
 
+		local maid = Maid.new()
+
 		local function failOnFirst(...)
-			pending = pending - 1
+			pending -= 1
+			latest = nil
 			sub:Fail(...)
 		end
 
 		local function completeOnAllPendingDone()
-			pending = pending - 1
+			pending -= 1
 			if pending == 0 then
+				latest = nil
 				sub:Complete()
 			end
 		end
 
+		local queueThread = nil
+		maid:GiveTask(function()
+			if queueThread then
+				MaidTaskUtils.doTask(queueThread)
+			end
+		end)
+
 		for key, observer in pairs(observables) do
-			if Observable.isObservable(observer) then
-				maid:GiveTask(observer:Subscribe(
-					function(value)
-						latest[key] = value
-						fireIfAllSet()
-					end,
-					failOnFirst,
-					completeOnAllPendingDone))
+			if not Observable.isObservable(observer) then
+				continue
 			end
+
+			maid:GiveTask(observer:Subscribe(
+				function(value)
+					if latest[key] == UNSET_VALUE then
+						unset -= 1
+					end
+
+					latest[key] = value
+
+					if unset == 0 and not queueThread then
+						queueThread = task.defer(function()
+							queueThread = nil
+							sub:Fire(table.freeze(table.clone(latest)))
+						end)
+					end
+				end,
+				failOnFirst,
+				completeOnAllPendingDone))
 		end
 
 		return maid
 	end)
 end
 
+
 --[=[
 	http://reactivex.io/documentation/operators/using.html
 

package/src/Shared/Subscription.lua

@@ -47,7 +47,7 @@ function Subscription.new(fireCallback, failCallback, completeCallback, observab
 
 	return setmetatable({
 		_state = SubscriptionStateTypes.PENDING;
-		_source = if ENABLE_STACK_TRACING then debug.traceback() else nil;
+		_source = if ENABLE_STACK_TRACING then debug.traceback("Subscription.new()", 3) else nil;
 		_observableSource = observableSource;
 		_fireCallback = fireCallback;
 		_failCallback = failCallback;
@@ -66,12 +66,19 @@ function Subscription:Fire(...)
 			self._fireCallback(...)
 		end
 	elseif self._state == SubscriptionStateTypes.CANCELLED then
-		warn("[Subscription.Fire] - We are cancelled, but events are still being pushed")
+		if self._fireCountAfterDeath then
+			self._fireCountAfterDeath += 1
+		else
+			self._fireCountAfterDeath = 1
+		end
+
+		if self._fireCountAfterDeath > 1 then
+			warn(debug.traceback(string.format("Subscription:Fire(%s) called %d times after death. Be sure to disconnect all events.", tostring(...), self._fireCountAfterDeath), 2))
 
-		if ENABLE_STACK_TRACING then
-			print(debug.traceback())
-			print(self._source)
-			print(self._observableSource)
+			if ENABLE_STACK_TRACING then
+				print(self._observableSource)
+				print(self._source)
+			end
 		end
 	end
 end
@@ -172,33 +179,35 @@ function Subscription:IsPending()
 	return self._state == SubscriptionStateTypes.PENDING
 end
 
-function Subscription:_assignCleanup(task)
+function Subscription:_assignCleanup(cleanupTask)
 	assert(self._cleanupTask == nil, "Already have _cleanupTask")
 
-	if MaidTaskUtils.isValidTask(task) then
+	if MaidTaskUtils.isValidTask(cleanupTask) then
 		if self._state ~= SubscriptionStateTypes.PENDING then
-			MaidTaskUtils.doTask(task)
+			MaidTaskUtils.doTask(cleanupTask)
 			return
 		end
 
-		self._cleanupTask = task
-	elseif task ~= nil then
-		error("Bad cleanup task")
+		self._cleanupTask = cleanupTask
+	elseif cleanupTask ~= nil then
+		error("Bad cleanup cleanupTask")
 	end
 end
 
 function Subscription:_doCleanup()
-	local task = self._cleanupTask
-	if not task then
-		return
-	end
+	local cleanupTask = self._cleanupTask
+	if cleanupTask then
+		self._cleanupTask = nil
 
-	self._cleanupTask = nil
-
-	-- The validity can change
-	if MaidTaskUtils.isValidTask(task) then
-		MaidTaskUtils.doTask(task)
+		-- The validity can change
+		if MaidTaskUtils.isValidTask(cleanupTask) then
+			MaidTaskUtils.doTask(cleanupTask)
+		end
 	end
+
+	self._fireCallback = nil
+	self._failCallback = nil
+	self._completeCallback = nil
 end
 
 --[=[
@@ -215,6 +224,7 @@ function Subscription:Destroy()
 	end
 
 	self:_doCleanup()
+
 end
 
 --[=[