From e4fa1e69e7ebfb627c7198fd1a9881e9327ec4d4 Mon Sep 17 00:00:00 2001
From: Pinapelz <yukais@pinapelz.com>
Date: Sat, 28 Jun 2025 17:26:46 -0700
Subject: initial commit: scaffolding

---
 .../rxjs/src/internal/operators/switchScan.ts      | 50 ++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 node_modules/rxjs/src/internal/operators/switchScan.ts

(limited to 'node_modules/rxjs/src/internal/operators/switchScan.ts')

diff --git a/node_modules/rxjs/src/internal/operators/switchScan.ts b/node_modules/rxjs/src/internal/operators/switchScan.ts
new file mode 100644
index 0000000..902a2a7
--- /dev/null
+++ b/node_modules/rxjs/src/internal/operators/switchScan.ts
@@ -0,0 +1,50 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types';
+import { switchMap } from './switchMap';
+import { operate } from '../util/lift';
+
+// TODO: Generate a marble diagram for these docs.
+
+/**
+ * Applies an accumulator function over the source Observable where the
+ * accumulator function itself returns an Observable, emitting values
+ * only from the most recently returned Observable.
+ *
+ * <span class="informal">It's like {@link mergeScan}, but only the most recent
+ * Observable returned by the accumulator is merged into the outer Observable.</span>
+ *
+ * @see {@link scan}
+ * @see {@link mergeScan}
+ * @see {@link switchMap}
+ *
+ * @param accumulator
+ * The accumulator function called on each source value.
+ * @param seed The initial accumulation value.
+ * @return A function that returns an observable of the accumulated values.
+ */
+export function switchScan<T, R, O extends ObservableInput<any>>(
+  accumulator: (acc: R, value: T, index: number) => O,
+  seed: R
+): OperatorFunction<T, ObservedValueOf<O>> {
+  return operate((source, subscriber) => {
+    // The state we will keep up to date to pass into our
+    // accumulator function at each new value from the source.
+    let state = seed;
+
+    // Use `switchMap` on our `source` to do the work of creating
+    // this operator. Note the backwards order here of `switchMap()(source)`
+    // to avoid needing to use `pipe` unnecessarily
+    switchMap(
+      // On each value from the source, call the accumulator with
+      // our previous state, the value and the index.
+      (value: T, index) => accumulator(state, value, index),
+      // Using the deprecated result selector here as a dirty trick
+      // to update our state with the flattened value.
+      (_, innerValue) => ((state = innerValue), innerValue)
+    )(source).subscribe(subscriber);
+
+    return () => {
+      // Release state on finalization
+      state = null!;
+    };
+  });
+}
-- 
cgit v1.2.3