@quenty/rx 7.10.0 → 7.11.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.11.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/rx@7.10.0...@quenty/rx@7.11.0) (2023-05-26)
+
+
+### Features
+
+* Add Rx.scan, Rx.reduce, and Rx.throttle ([995a435](https://github.com/Quenty/NevermoreEngine/commit/995a43579ec836c0a300013a2326740f2b14b1d8))
+
+
+
+
+
 # [7.10.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/rx@7.9.1...@quenty/rx@7.10.0) (2023-04-10)
 
 **Note:** Version bump only for package @quenty/rx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/rx",
-  "version": "7.10.0",
+  "version": "7.11.0",
   "description": "Quenty's reactive library for Roblox",
   "keywords": [
     "Roblox",
@@ -28,11 +28,11 @@
   ],
   "dependencies": {
     "@quenty/cancellabledelay": "^3.4.0",
-    "@quenty/canceltoken": "^6.5.0",
+    "@quenty/canceltoken": "^6.6.0",
     "@quenty/loader": "^6.2.1",
     "@quenty/maid": "^2.5.0",
     "@quenty/promise": "^6.5.0",
-    "@quenty/signal": "^2.3.0",
+    "@quenty/signal": "^2.4.0",
     "@quenty/symbol": "^2.2.0",
     "@quenty/table": "^3.2.0",
     "@quenty/throttle": "^6.2.1"
@@ -40,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3306212248c310731931ad45d8b86dc7247f2a5d"
+  "gitHead": "11058e90e51ea83d3dad6ae9abe59cc19c36b94b"
 }

package/src/Shared/Rx.lua

@@ -575,6 +575,81 @@ function Rx.startWith(values)
 	end
 end
 
+--[=[
+	The Scan operator applies a function to the first item emitted by the source Observable and then
+	emits the result of that function as its own first emission. It also feeds the result of the function
+	back into the function along with the second item emitted by the source Observable in order to generate
+	its second emission. It continues to feed back its own subsequent emissions along with the subsequent
+	emissions from the source Observable in order to create the rest of its sequence.
+
+	https://reactivex.io/documentation/operators/scan.html
+
+	@param reducer function
+	@param seed any | nil
+	@return (source: Observable) -> Observable
+]=]
+function Rx.scan(reducer, seed)
+	assert(type(reducer) == "function", "Bad reducer")
+
+	return function(source)
+		assert(Observable.isObservable(source), "Bad observable")
+
+		return Observable.new(function(sub)
+			local maid = Maid.new()
+			local current = seed
+
+			maid:GiveTask(source:Subscribe(
+				function(...)
+					current = reducer(current, ...)
+					sub:Fire(current)
+				end,
+				sub:GetFailComplete()))
+
+			return maid
+		end)
+	end
+end
+
+--[=[
+	The Reduce operator applies a function to the first item emitted by the source Observable and
+	then feeds the result of the function back into the function along with the second item emitted
+	by the source Observable, continuing this process until the source Observable emits its final
+	item and completes, whereupon the Observable returned from Reduce emits the final value returned
+	from the function.
+
+	https://reactivex.io/documentation/operators/reduce.html
+
+	@param reducer function
+	@param seed any | nil
+	@return (source: Observable) -> Observable
+]=]
+function Rx.reduce(reducer, seed)
+	assert(type(reducer) == "function", "Bad reducer")
+
+	return function(source)
+		assert(Observable.isObservable(source), "Bad observable")
+
+		return Observable.new(function(sub)
+			local maid = Maid.new()
+			local current = seed
+
+			maid:GiveTask(source:Subscribe(
+				function(...)
+					current = reducer(current, ...)
+				end,
+				function(...)
+					sub:Fail(...)
+				end),
+				function()
+					-- On complete emit the result.
+					sub:Fire(current)
+				end)
+
+			return maid
+		end)
+	end
+end
+
 --[=[
 	Defaults the observable to a value if it isn't fired immediately
 
@@ -1010,6 +1085,62 @@ function Rx.flatMap(project, resultSelector)
 	end
 end
 
+--[=[
+	Switches to a new observable from the current observable
+
+	https://rxjs.dev/api/operators/switchMap
+
+	As each observable shows up, a new observable is mapped from that observable.
+
+	The old observable is disconnected.
+
+	Use Rx.switchMap to switch to a new RunService event
+
+	```lua
+	Rx.of(1, 2, 3):Pipe({
+		Rx.switchMap(function(value)
+			local startTime = os.clock()
+
+			-- Only the last observable returned will continue to emit,
+			-- others are disconnected.
+			return Rx.of(RunService.RenderStepped):Pipe({
+				Rx.map(function()
+					return os.clock() - startTime, value
+				end);
+			});
+		end);
+	}):Subscribe(print) --> 0.002352342, 3
+	```
+
+	Use Rx.switchMap() as a simple map...
+
+	```lua
+	Rx.of(1, 2, 3):Pipe({
+		Rx.switchMap(function(value)
+			print(value) --> 1 (and then 2, and then 3)
+
+			return Rx.of(value*2)
+		end);
+	}):Subscribe(print) --> 2, 4, 6
+
+	```
+
+	Use Rx.switchMap() with delayed input (to swap to a new one)
+
+	```lua
+	Rx.of(1, 2, 3):Pipe({
+		Rx.switchMap(function(value)
+			-- Emit 1 second later
+			return Rx.of(value*2):Pipe({
+				Rx.delay(1); -- These will each get cancelled
+			})
+		end);
+	}):Subscribe(print) --> 6 (other results were cancelled)
+	```
+
+	@param project function
+	@return Observable
+]=]
 function Rx.switchMap(project)
 	return Rx.pipe({
 		Rx.map(project);
@@ -1684,6 +1815,7 @@ function Rx.throttleDefer()
 						end
 					end)
 				else
+
 					lastResult = table.pack(...)
 				end
 			end, sub:GetFailComplete()))
@@ -1693,4 +1825,52 @@ function Rx.throttleDefer()
 	end
 end
 
+--[=[
+	Throttles emission of observables on the defer stack to the last emission.
+
+	https://rxjs.dev/api/operators/throttle
+
+	@param durationSelector (T: value) -> Observable
+	@return (source: Observable<T>) -> Observable<T>
+]=]
+function Rx.throttle(durationSelector)
+	return function(source)
+		assert(Observable.isObservable(source), "Bad observable")
+
+		return Observable.new(function(sub)
+			local topMaid = Maid.new()
+
+			local lastResult
+
+			topMaid:GiveTask(source:Subscribe(function(...)
+				if not lastResult then
+					lastResult = table.pack(...)
+
+					-- Queue up our result
+					local maid = Maid.new()
+
+					maid:GiveTask(durationSelector(lastResult):Subscribe(function()
+						local current = lastResult
+						lastResult = nil
+
+						if sub:IsPending() then
+							sub:Fire(table.unpack(current, 1, current.n))
+						end
+
+						if topMaid._currentQueue == maid then
+							topMaid._currentQueue = nil
+						end
+					end))
+
+					topMaid._currentQueue = maid
+				else
+					lastResult = table.pack(...)
+				end
+			end, sub:GetFailComplete()))
+
+			return topMaid
+		end)
+	end
+end
+
 return Rx