feat(tap-once): enhance tapOnce and tapOnceOnFirstTruthy to ensure unique state per subscription

Author: endlacer

libs/ngxtension/tapOnce/src/tap-once.spec.ts

@@ -2,37 +2,60 @@ import { from, toArray } from 'rxjs';
 import { tapOnce, tapOnceOnFirstTruthy } from './tap-once';
 
 describe(tapOnce.name, () => {
-	it('should execute the function only once at the specified index', (done) => {
+	it('should execute the function only once at the default index 0', (done) => {
 		const tapFn = jest.fn();
 		const in$ = from([1, 2, 3, 4, 5]);
-		const out$ = in$.pipe(tapOnce(tapFn, 2));
+		const out$ = in$.pipe(tapOnce(tapFn));
 
 		out$.pipe(toArray()).subscribe((r) => {
 			expect(r).toEqual([1, 2, 3, 4, 5]);
 			expect(tapFn).toHaveBeenCalledTimes(1);
-			expect(tapFn).toHaveBeenCalledWith(3);
+			expect(tapFn).toHaveBeenCalledWith(1);
 			done();
 		});
 	});
 
-	it('should execute the function only once at the default index 0', (done) => {
+	it('should execute the function only once at the specified index', (done) => {
 		const tapFn = jest.fn();
 		const in$ = from([1, 2, 3, 4, 5]);
-		const out$ = in$.pipe(tapOnce(tapFn));
+		const out$ = in$.pipe(tapOnce(tapFn, 2));
 
 		out$.pipe(toArray()).subscribe((r) => {
 			expect(r).toEqual([1, 2, 3, 4, 5]);
 			expect(tapFn).toHaveBeenCalledTimes(1);
-			expect(tapFn).toHaveBeenCalledWith(1);
+			expect(tapFn).toHaveBeenCalledWith(3);
 			done();
 		});
 	});
 
 	it('should throw an error if tapIndex is negative', () => {
-		expect(() => tapOnce(() => {}, -1)).toThrow(
+		expect(() => tapOnce(() => void 0, -1)).toThrow(
 			'tapIndex must be a non-negative integer',
 		);
 	});
+
+	it('should not share state across multiple subscriptions', (done) => {
+		const tapFn = jest.fn();
+		const in$ = from([1, 2, 3, 4, 5]);
+		const out$ = in$.pipe(tapOnce(tapFn, 1));
+
+		// First subscription
+		out$.pipe(toArray()).subscribe((r1) => {
+			expect(r1).toEqual([1, 2, 3, 4, 5]);
+			expect(tapFn).toHaveBeenCalledTimes(1);
+			expect(tapFn).toHaveBeenCalledWith(2);
+
+			tapFn.mockClear();
+
+			// Second subscription - should also trigger the tap function
+			out$.pipe(toArray()).subscribe((r2) => {
+				expect(r2).toEqual([1, 2, 3, 4, 5]);
+				expect(tapFn).toHaveBeenCalledTimes(1);
+				expect(tapFn).toHaveBeenCalledWith(2);
+				done();
+			});
+		});
+	});
 });
 
 describe(tapOnceOnFirstTruthy.name, () => {
@@ -73,4 +96,27 @@ describe(tapOnceOnFirstTruthy.name, () => {
 			done();
 		});
 	});
+
+	it('should not share state across multiple subscriptions', (done) => {
+		const tapFn = jest.fn();
+		const in$ = from([0, null, false, 3, 4, 5]);
+		const out$ = in$.pipe(tapOnceOnFirstTruthy(tapFn));
+
+		// First subscription
+		out$.pipe(toArray()).subscribe((r1) => {
+			expect(r1).toEqual([0, null, false, 3, 4, 5]);
+			expect(tapFn).toHaveBeenCalledTimes(1);
+			expect(tapFn).toHaveBeenCalledWith(3);
+
+			tapFn.mockClear();
+
+			// Second subscription - should also trigger the tap function
+			out$.pipe(toArray()).subscribe((r2) => {
+				expect(r2).toEqual([0, null, false, 3, 4, 5]);
+				expect(tapFn).toHaveBeenCalledTimes(1);
+				expect(tapFn).toHaveBeenCalledWith(3);
+				done();
+			});
+		});
+	});
 });

libs/ngxtension/tapOnce/src/tap-once.ts

@@ -1,28 +1,33 @@
-import { MonoTypeOperatorFunction, concatMap, of, type Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
+import { defer, MonoTypeOperatorFunction, Observable, tap } from 'rxjs';
 
 /**
  * Executes the provided function only once when the first truthy value is emitted.
+ * Uses `defer` to ensure state is unique per subscription.
+ *
  * @param tapFn - Function to execute on the first truthy value.
  * @returns MonoTypeOperatorFunction
  */
 export function tapOnceOnFirstTruthy<T>(
 	tapFn: (t: T) => void,
 ): MonoTypeOperatorFunction<T> {
-	let firstTruthy = true;
 	return (source$: Observable<T>) =>
-		source$.pipe(
-			tap((value) => {
-				if (firstTruthy && !!value) {
-					tapFn(value);
-					firstTruthy = false;
-				}
-			}),
-		);
+		defer(() => {
+			let firstTruthy = true;
+			return source$.pipe(
+				tap((value) => {
+					if (firstTruthy && !!value) {
+						tapFn(value);
+						firstTruthy = false;
+					}
+				}),
+			);
+		});
 }
 
 /**
  * Executes the provided function only once when the value at the specified index is emitted.
+ * Uses `defer` to track index without the overhead of `concatMap`.
+ *
  * @param tapFn - Function to execute on the value at the specified index.
  * @param tapIndex - Index at which to execute the function (default is 0).
  * @returns MonoTypeOperatorFunction
@@ -34,13 +39,17 @@ export function tapOnce<T>(
 	if (tapIndex < 0) {
 		throw new Error('tapIndex must be a non-negative integer');
 	}
+
 	return (source$: Observable<T>) =>
-		source$.pipe(
-			concatMap((value, index) => {
-				if (index === tapIndex) {
-					tapFn(value);
-				}
-				return of(value);
-			}),
-		);
+		defer(() => {
+			let currentIndex = 0;
+			return source$.pipe(
+				tap((value) => {
+					if (currentIndex === tapIndex) {
+						tapFn(value);
+					}
+					currentIndex++;
+				}),
+			);
+		});
 }